feat: adopt zero-bloat compiled governance stack & suppression hygiene gates

2026-11-07 10:46:10 -10:00 · 2026-08-20 16:18:40 -04:00
1 parent cc5f043aa6
commit 7c1565468f
@@ -0,0 +1,217 @@
+# **Architectural Assessment and Zero-Bloat Governance Stack for Autonomous AI Coding Agents**
+
+## **Phase 1: Agent-Proof Baseline Analysis**
+
+The widespread integration of autonomous AI coding agents—such as Claude Code, Cursor, Aider, OpenAI Codex, and Antigravity—into production software workflows has fundamentally transformed software synthesis1. While these generative tools achieve remarkable speed when drafting complex implementations, their underlying probabilistic architecture introduces non-deterministic failure modes3. These include subtle security vulnerabilities, structural drift, circular dependency chains, dead export accumulation, and architectural layer violations4. The Heretek-AI/Agent-Proof repository addresses this systemic challenge by applying deterministic verification principles to AI-generated code1. The core operational premise rests upon proof-carrying code paradigms, wherein untrusted code synthesized by an autonomous agent must present verifiable static proofs of security and structural correctness before being committed or executed in runtime environments3.  
+An architectural audit of early agent verification frameworks, including the baseline mechanisms within Heretek-AI/Agent-Proof and related agent harnesses1, reveals significant friction with real-time development workflows. Traditional verification implementations rely on multi-language wrapper scripts that invoke interpreted linters, dynamic analysis engines, and multi-step evaluation harnesses1. While these harnesses succeed in catching post-hoc bugs, they introduce severe execution overhead that violates the sub-second response mandate required for real-time human-agent pairing and sub-second auto-repair loops4.
+
+| Architectural Dimension | Traditional Agent Verification Harness | Zero-Bloat Native Interceptor Architecture |
+| :---- | :---- | :---- |
+| **Execution Engine** | Interrogated Python virtual environments, Node.js runtimes, or Java Virtual Machines (JVM). | Standalone compiled native binaries (Rust, Go) executed directly by the host operating system4. |
+| **Cold-Start Latency** | High overhead ranging from 800 ms to over 4,000 ms per file invocation8. | Sub-second execution achieving 5 ms to 50 ms response times per changed file4. |
+| **Memory Footprint** | Heavy runtime memory consumption (200 MB – 1.5 GB) per execution context8. | Minimal resident set size (8 MB – 30 MB) per invocation. |
+| **AST Parsing Strategy** | Dynamic language bindings, heavy interpreted AST objects, and dynamic evaluation wrappers. | Ultra-fast native parsing engines (e.g., Tree-sitter, Oxc, Rust AST) operating in compiled binary space5. |
+| **Evaluation Determinism** | Often relies on secondary LLM evaluation calls, introducing non-determinism and financial cost. | Strictly deterministic static analysis with stable rule fingerprints and reproducible findings4. |
+| **Agent Integration Surface** | Unstructured CLI stdout parsed via fragile regex or custom JSON converters. | Standardized LSP diagnostic publishing and MCP tool payloads with exact byte ranges and quick-fixes2. |
+
+Primary structural bottlenecks within traditional agent validation loops stem from process bootstrapping and dependency initialization. Spawning a Python virtual environment to run an AST security check or initializing a Node.js process tree introduces cold-start latencies that frequently exceed two seconds8. When an autonomous coding agent performs an iterative sequence of ten micro-edits during a complex refactoring task, cumulative harness latency delays execution by tens of seconds. This causes context window fragmentation, API timeout risks, and excessive LLM token expenditure.  
+Furthermore, traditional harnesses frequently attempt to enforce governance by making secondary calls to evaluator LLMs. Utilizing probabilistic models to audit probabilistic outputs creates a non-deterministic validation loop characterized by high monetary cost, unpredictable evaluation criteria, and latency profiles ranging from three to fifteen seconds. To establish an ultra-fast guardrail system, governance must shift entirely to binary-native, deterministic static analysis tools that evaluate abstract syntax trees and module graphs in single-digit milliseconds4.  
+Another critical gap in baseline verification harnesses is the absence of native Language Server Protocol (LSP) and Model Context Protocol (MCP) diagnostic envelope integration2. Traditional tools output unstructured text to stdout or dump proprietary JSON files. Without automated translation into structured LSP diagnostic objects featuring exact byte-range locations, deterministic error codes, and inline quick-fix refactoring patches, autonomous agents cannot efficiently parse the error context4. This forces the agent into blind guessing cycles rather than immediate, automated self-correction4.
+
+## **Phase 2: The Ruthless Cull (Tool Filtering)**
+
+To fulfill the zero-bloat constraint, candidate tools must satisfy three non-negotiable criteria: binary-native execution without external language runtimes, sub-second latency on incremental file modifications, and structured diagnostic output capability4. The provided candidate tool list has been evaluated against these constraints and categorized into three distinct buckets: Keepers, Misfits, and Aggregators/Wrappers.
+
+| Candidate Tool | Target Ecosystem | Engine / Binary Language | Latency Profile (Incremental File) | Architectural Verdict | Primary Justification |
+| :---- | :---- | :---- | :---- | :---- | :---- |
+| **ast-grep** | Polyglot (25+ Languages) | Rust (Tree-sitter Engine) | 5 ms – 20 ms | **Keeper** | Ultra-fast structural AST search and rewriting9; zero external runtime overhead. |
+| **Ruff** | Python | Rust (Compiled Binary) | 10 ms – 30 ms | **Keeper** | Replaces Flake8, Isort, and Bandit with a 100x speedup in a standalone binary. |
+| **fallow** | JavaScript / TypeScript | Rust (Oxc Parser Engine) | 15 ms – 50 ms | **Keeper** | Fast codebase intelligence for dead code, circular deps, complexity, and boundaries4. |
+| **tach** | Python | Rust (Compiled Binary) | 10 ms – 25 ms | **Keeper** | Enforces Python modular dependency boundaries with zero runtime impact6. |
+| **zizmor** | GitHub Actions / CI/CD | Rust (Compiled Binary) | 15 ms – 40 ms | **Keeper** | Fast static analysis of GitHub workflow security vulnerabilities11. |
+| **gosec** | Go | Go (Compiled Binary) | 30 ms – 90 ms | **Keeper** | Native Go AST security scanner executing directly as a single static binary. |
+| **revive** | Go | Go (Compiled Binary) | 20 ms – 60 ms | **Keeper** | Fast, configurable linter replacing legacy golint with zero runtime dependencies. |
+| **hadolint** | Docker / Containers | Haskell / Rust Binary | 10 ms – 30 ms | **Keeper** | Standalone Dockerfile static analysis tool providing instantaneous rule checking. |
+| **kube-score** | Kubernetes YAML | Go (Compiled Binary) | 15 ms – 45 ms | **Keeper** | Native Go binary for static security analysis of Kubernetes object manifests. |
+| **tfsec** | Terraform / IaC | Go (Compiled Binary) | 30 ms – 80 ms | **Keeper** | Ultra-fast static analysis for Terraform templates prior to cloud deployment. |
+| **grype** | Supply Chain / Vulnerabilities | Go (Compiled Binary) | 100 ms – 300 ms | **Keeper (Pre-commit)** | Fast vulnerability scanner for lockfiles and SBOMs operating via single binary. |
+| **syft** | Supply Chain / SBOM | Go (Compiled Binary) | 80 ms – 250 ms | **Keeper (Pre-commit)** | Sub-second SBOM generation from source trees and lockfiles. |
+| **go-tools** | Go | Go (Compiled Binary) | 40 ms – 120 ms | **Keeper (Pre-commit)** | Ships staticcheck binary for deep Go code analysis and correctness checks. |
+| **Semgrep** | Polyglot SAST | OCaml / Python Core | 300 ms – 1,500 ms | **Misfit** | Heavy executable bundle and rule loading overhead exceed sub-second constraints9. |
+| **ESLint** | JavaScript / TypeScript | Node.js (Requires V8) | 500 ms – 2,000 ms | **Misfit** | Requires large node\_modules trees and V8 runtime; superseded by fallow4. |
+| **PMD** | Java / Apex / Multi | Java (JVM Required) | 1,500 ms – 4,000 ms | **Misfit** | High JVM initialization latency; violates zero-dependency constraint. |
+| **Phan** | PHP | PHP (Requires PHP Engine) | 800 ms – 2,500 ms | **Misfit** | Requires PHP interpreter runtime and AST extension; heavy startup footprint. |
+| **Bandit** | Python | Python (Requires PyEnv) | 400 ms – 1,200 ms | **Misfit** | Requires Python virtualenv; rules fully superseded by Rust-native Ruff. |
+| **Checkstyle** | Java | Java (JVM Required) | 1,200 ms – 3,500 ms | **Misfit** | JVM cold-start overhead is unacceptable for real-time post-edit interception. |
+| **RuboCop** | Ruby | Ruby (Requires Ruby VM) | 1,000 ms – 3,000 ms | **Misfit** | Heavy Ruby VM dependency and high resident memory overhead per invocation. |
+| **Bearer** | Polyglot SAST | Go / Heavy Binary | 800 ms – 2,500 ms | **Misfit** | Large memory footprint and slow static flow analysis; too heavy for post-edit loop. |
+| **Codelyzer** | Angular / TypeScript | Node.js (Requires V8) | 800 ms – 2,200 ms | **Misfit** | Deprecated Node.js package requiring heavy Angular compiler dependencies. |
+| **PyT** | Python | Python (Requires PyEnv) | 600 ms – 2,000 ms | **Misfit** | Unmaintained Python static taint analyzer; requires full Python runtime environment. |
+| **WALA** | Java / JS Analysis | Java (JVM Required) | 3,000 ms – 10,000 ms+ | **Misfit** | Heavy academic analysis framework; extremely slow dynamic and static solver loop. |
+| **Putout** | JavaScript | Node.js (Requires V8) | 600 ms – 2,200 ms | **Misfit** | Heavy Node.js transform runner; introduces node module dependency bloat. |
+| **OSS-Fuzz** | Polyglot (Fuzzing) | C++ / Python Infrastructure | Minutes to Hours | **Misfit** | Continuous fuzzing platform; non-deterministic and incompatible with real-time loops. |
+| **syzkaller** | Kernel / OS | Go / C (Coverage Fuzzer) | Continuous / Hours | **Misfit** | Kernel-level coverage-guided fuzzer; irrelevant for real-time app code edits. |
+| **WTF** | x86/x64 Binary Fuzzer | C++ / Hypervisor | Minutes to Hours | **Misfit** | Dynamic hypervisor-based fuzzer; far too heavy for editor loop interceptors. |
+| **MobSFScan** | Mobile (Android/iOS) | Python (Requires PyEnv) | 1,000 ms – 3,500 ms | **Misfit** | Python dependency; specialized mobile focus with slow rule execution times. |
+| **Medusa** | Smart Contracts | Go / Python / Fuzzer | Seconds to Minutes | **Misfit** | Dynamic smart contract fuzzer; unsuitable for real-time post-edit static guardrails. |
+| **PentestingEverything** | Offensive Security | Shell / Python Scripts | N/A (Offensive) | **Misfit** | Collection of pentesting scripts; not an executable static analysis tool. |
+| **jadx-ai-mcp** | Android RE / Java | Java / Kotlin Engine | 3,000 ms – 10,000 ms | **Misfit** | Reverse engineering tool for APK decompilation; inappropriate for editor guardrails. |
+| **PHP-CS-Fixer** | PHP | PHP (Requires PHP Engine) | 700 ms – 2,000 ms | **Misfit** | Requires PHP interpreter runtime; introduces language runtime bloat. |
+| **Clair** | Container SAST | Go / PostgreSql Service | 2,000 ms – 8,000 ms | **Misfit** | Requires external database server infrastructure for vulnerability scanning. |
+| **SonarQube** | Polyglot SAST | Java / Monolithic Server | 5,000 ms – 30,000 ms | **Misfit** | Enterprise server requiring JVM and heavy background processing infrastructure. |
+| **PHP\_CodeSniffer** | PHP | PHP (Requires PHP Engine) | 800 ms – 2,200 ms | **Misfit** | Interpreted PHP runtime script; fails sub-second execution mandate. |
+| **Checkov** | IaC (Terraform/Cloud) | Python (Requires PyEnv) | 2,000 ms – 6,000 ms | **Misfit** | Extremely heavy Python distribution (\>200MB); unacceptable cold-start latency. |
+| **Brakeman** | Ruby on Rails | Ruby (Requires Ruby VM) | 1,200 ms – 4,000 ms | **Misfit** | Requires Ruby runtime; slow full-AST analysis cycle on large Rails codebases. |
+| **dependency-cruiser** | JS / TS Module Graph | Node.js (Requires V8) | 800 ms – 3,000 ms | **Misfit** | Slow module graph traversal in Node; fully superseded by Rust-native fallow4. |
+| **detekt** | Kotlin | Java / Kotlin (JVM) | 2,000 ms – 5,000 ms | **Misfit** | Heavy JVM reliance and Kotlin compiler daemon overhead. |
+| **cppcheck** | C / C++ | C++ (Compiled Binary) | 200 ms – 1,500 ms | **Misfit** | Standalone binary, but execution speed degrades rapidly on complex header trees. |
+| **Reviewdog** | Output Aggregator | Go (Compiled Binary) | 50 ms – 150 ms | **Aggregator** | Lightweight CLI wrapper, but adds redundant process overhead inside an LSP bridge. |
+| **Horusec** | Security Orchestrator | Go / Docker Engine | 3,000 ms – 15,000 ms | **Aggregator** | Monolithic orchestrator spawning containers/subprocesses; severe harness bloat. |
+| **static-analysis** | Meta-resource | N/A (Curated List) | N/A | **Aggregator** | Curated catalog of static analysis tools; not an executable software binary. |
+
+### **Disqualification Rationale for Misfit Categories**
+
+JVM-based tools—including PMD, Checkstyle, SonarQube, WALA, and Detekt—are disqualified primarily due to the immutable cold-start penalty of the Java Virtual Machine. Initializing the JVM, loading bytecode classes, and warming up JIT compilers requires between 1,200 ms and 5,000 ms per invocation. In an interactive AI coding session where an agent issues rapid micro-edits, JVM initialization introduces unacceptable delays that break the real-time interaction model.  
+Interpreted and runtime-dependent tools—such as Bandit, RuboCop, Phan, Brakeman, PHP-CS-Fixer, PHP\_CodeSniffer, PyT, Checkov, and MobSFScan—require pre-configured interpreter environments (Python venvs, Ruby VMs, PHP runtimes) on the host machine. This directly violates the zero-bloat mandate by requiring target codebases to maintain extensive development dependencies. Furthermore, interpreted AST traversals are orders of magnitude slower than compiled Rust or Go parsers, making them unfit for sub-second execution loops5.  
+Heavy Node.js tools—including ESLint, Putout, Codelyzer, and Dependency-Cruiser—introduce substantial workspace bloat through deep node\_modules dependency trees. Traversing complex TypeScript syntax trees in single-threaded JavaScript runtimes yields execution latencies between 500 ms and 3,000 ms. Modern Rust-native alternatives built on high-performance parsing frameworks (such as Oxc and Tree-sitter) analyze complete project module graphs in a fraction of that time while shipping as self-contained binaries5.  
+Dynamic fuzzers and symbolic execution engines—including OSS-Fuzz, Syzkaller, WTF, and Medusa—operate on non-deterministic, long-running execution loops designed to uncover edge-case memory corruption or smart contract failures over hours or days. Positioning a fuzzer within a real-time post-edit editor loop represents an architectural mismatch. Post-edit interceptors require instantaneous, deterministic feedback to validate immediate syntax and logic changes.
+
+## **Phase 3: The Optimized Agent-Proof Stack**
+
+By culling runtime-dependent linters, interpreted wrappers, and heavy orchestrators, we construct an optimized governance stack composed entirely of compiled, standalone binaries (primarily Rust and Go). This architecture delivers broad vulnerability and bug coverage across major programming languages and infrastructure frameworks while maintaining a sub-second execution footprint4.
+
+| Language / Domain | Selected Native Binary | Target Vulnerabilities & Bug Classes Covered | Execution Latency | Memory Footprint | Governance Tier |
+| :---- | :---- | :---- | :---- | :---- | :---- |
+| **Universal (25+ Languages)** | ast-grep | Structural SAST, unsafe API usage, hardcoded secrets, injection patterns, custom rule enforcement9. | 5 ms – 20 ms | \~12 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **Python Syntax & Security** | Ruff | Syntax errors, dynamic code execution (eval), SQL injection patterns, type flaws, unused imports. | 10 ms – 30 ms | \~15 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **Python Architecture** | Tach | Modular boundary violations, illegal cross-domain imports, architectural layer erosion6. | 10 ms – 25 ms | \~10 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **JavaScript / TypeScript** | fallow | Unused exports/types, circular dependencies, code duplication, cognitive complexity, boundary leaks4. | 15 ms – 50 ms | \~25 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **Go Code & Security** | gosec & revive | Unsafe memory access, hardcoded credentials, weak cryptography, naming anti-patterns, race conditions. | 20 ms – 80 ms | \~25 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **Docker / Containers** | hadolint | Root user execution, untagged images, unpinned package installs, shell injection in RUN blocks. | 10 ms – 30 ms | \~8 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **Kubernetes Infrastructure** | kube-score | Missing resource limits, privileged containers, missing security contexts, unsafe pod specs. | 15 ms – 45 ms | \~12 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **Terraform / IaC** | tfsec | Unencrypted storage buckets, overly permissive security groups, public S3 access, IAM misconfigurations. | 30 ms – 80 ms | \~18 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **GitHub Workflows / CI** | zizmor | Unpinned action SHAs, expression injection, overly permissive GITHUB\_TOKEN scopes11. | 15 ms – 40 ms | \~14 MB | Tier 1 (Post-Edit) & Tier 2 (Pre-Commit) |
+| **Supply Chain & Vulnerabilities** | grype & syft | Known CVEs in project lockfiles, malicious dependency versions, license compliance violations. | 80 ms – 300 ms | \~45 MB | Tier 2 (Pre-Commit Gate) |
+
+### **Core Architectural Synergies and Coverage Mechanics**
+
+The selected tools complement one another without functional overlap or harness bloat, operating in unison across the multi-tier governance model.
+
+\+---------------------------------------------------------------------------------------------------+  
+|                            MULTI-TIER ZERO-BLOAT GOVERNANCE PIPELINE                              |  
+\+---------------------------------------------------------------------------------------------------+  
+| TIER 1: SUB-SECOND POST-EDIT INTERCEPTORS (\< 50ms)                                                |  
+| Parallel Binary Dispatch: ast-grep | Ruff | fallow | Tach | gosec | revive | hadolint | zizmor  |  
+| Trigger: Editor Save / Buffer Mutation Event                                                      |  
+| Output: Direct LSP Diagnostic Payload Ingestion into AI Agent Context                             |  
+\+---------------------------------------------------------------------------------------------------+  
+                                                  |  
+                                                  v  
+\+---------------------------------------------------------------------------------------------------+  
+| TIER 2: PRE-COMMIT GATES (\< 300ms)                                                                |  
+| Incremental Delta Audit: Full Workspace Scans \+ Supply Chain Checks (grype \+ syft \+ tfsec)        |  
+| Trigger: Git Hook / Agent Commit Action                                                           |  
+| Output: Commit Approval or Hard Rejection with Blocking SARIF Log                                 |  
+\+---------------------------------------------------------------------------------------------------+  
+                                                  |  
+                                                  v  
+\+---------------------------------------------------------------------------------------------------+  
+| TIER 3: LSP / MCP AGENT DIAGNOSTIC ENVELOPE (Continuous)                                          |  
+| Unified Diagnostic Stream Engine (agent-proof-envelope)                                           |  
+| Translation: Native Tool Output \-\> Unified SARIF \-\> LSP textDocument/publishDiagnostics / MCP Context|  
+| Output: Real-Time Byte-Range Error Highlighting & Auto-Repair Patch Instructions for AI Agents    |  
+\+---------------------------------------------------------------------------------------------------+
+
+Universal AST querying is anchored by ast-grep, which utilizes Tree-sitter parsers to execute structural pattern matching across more than 25 programming languages9. Rather than maintaining dozens of language-specific linters, DevSecOps teams write declarative YAML rules that intercept dangerous API patterns, un-sanitized dynamic evaluations, and hardcoded secrets in single-digit milliseconds9.  
+For JavaScript and TypeScript environments, fallow delivers deep codebase intelligence that standard file-by-file linters cannot provide5. Built natively in Rust on the Oxc parser ecosystem, fallow constructs the full module graph in milliseconds2. It detects dead code generated during agent refactoring, identifies circular export dependencies, monitors cognitive complexity hotspots, and enforces strict architecture boundaries4.  
+In Python codebases, Ruff handles syntax, security, and linting checks at 100x the speed of legacy Python tools, completely eliminating the need for Flake8 or Bandit. Concurrently, Tach operates as a Rust-compiled architecture enforcer that monitors Python module import boundaries, preventing AI agents from breaking modular separation6.  
+Cloud-native infrastructure and CI/CD security are protected at the source file level. hadolint verifies Dockerfile security patterns instantly, kube-score validates Kubernetes manifests, tfsec scans Terraform code for cloud misconfigurations, and zizmor audits GitHub Actions workflows to block expression injection and credential leakage vectors11.  
+During Tier 2 pre-commit gates, grype and syft perform sub-second supply chain audits across dependency lockfiles, ensuring AI agents do not introduce vulnerable or compromised external packages into the repository.
+
+## **Phase 4: Implementation Blueprint (The LSP Envelope)**
+
+To bridge these high-speed native binaries directly into autonomous coding agents (Claude Code, Cursor, Aider, OpenAI Codex, and Antigravity), we design a unified, zero-harness bridge titled agent-proof-envelope. Compiled as a single Rust binary, agent-proof-envelope acts as an ultra-lean Language Server Protocol diagnostic broker and Model Context Protocol server2. It intercepts file save events, executes matched security binaries asynchronously in parallel threads, aggregates stdout JSON streams, normalizes findings into standard SARIF formats, and broadcasts LSP diagnostic objects directly to the editing agent2.
+
+| Pipeline Phase | Operational Mechanism | Latency Budget | Output Contract |
+| :---- | :---- | :---- | :---- |
+| **1\. File Mutation Interception** | Async file-watch hook intercepts buffer modifications from the AI agent environment2. | \< 2 ms | Modified file path, buffer byte array, and active workspace root path. |
+| **2\. Parallel Binary Dispatch** | Process dispatcher executes language-matched compiled binaries concurrently on thread pools4. | 10 ms – 50 ms | Raw structured JSON streams emitted to stdout from individual tool executions4. |
+| **3\. SARIF Aggregation & Deduplication** | Bridge normalizes tool outputs into unified SARIF model, merges overlapping rules, and assigns diagnostic severities4. | \< 5 ms | Deduplicated SARIF payload with exact line/character ranges and patch data4. |
+| **4\. LSP Diagnostic Publication** | Server broadcasts textDocument/publishDiagnostics payload or MCP context response back to the agent2. | \< 3 ms | Standard LSP JSON-RPC message containing diagnostics, rule IDs, and quick-fix edits. |
+| **5\. Deterministic Agent Auto-Repair** | AI agent ingests precise diagnostic ranges and quick-fixes to apply deterministic code updates without human intervention4. | Sub-second total loop | Resolved issue state verified by secondary micro-check4. |
+
+### **Data Pipeline and Conversion Spec**
+
+When an agent mutates a file, agent-proof-envelope intercepts the buffer write event and determines which subset of binary tools to spawn based on file extensions. Native executables run asynchronously in isolated sub-threads, writing raw JSON results to stdio buffers. The envelope aggregates these outputs into a SARIF structure and translates them into an LSP textDocument/publishDiagnostics notification payload.
+
+JSON  
+{  
+  "jsonrpc": "2.0",  
+  "method": "textDocument/publishDiagnostics",  
+  "params": {  
+    "uri": "file:///workspace/src/auth/session.ts",  
+    "diagnostics": \[  
+      {  
+        "range": {  
+          "start": { "line": 42, "character": 8 },  
+          "end": { "line": 42, "character": 38 }  
+        },  
+        "severity": 1,  
+        "code": "FALLOW-CIRCULAR-DEP",  
+        "source": "Agent-Proof (fallow)",  
+        "message": "CRITICAL: Circular export dependency introduced between 'session.ts' and 'user.ts'. Breaks modular isolation.",  
+        "data": {  
+          "ruleId": "fallow/circular-dependency",  
+          "quickFix": {  
+            "title": "Extract shared session interface to 'session-types.ts'",  
+            "edits": \[  
+              {  
+                "range": {  
+                  "start": { "line": 42, "character": 8 },  
+                  "end": { "line": 42, "character": 38 }  
+                },  
+                "newText": "import type { SessionPayload } from './session-types';"  
+              }  
+            \]  
+          }  
+        }  
+      }  
+    \]  
+  }  
+}
+
+### **Agent Integration Adapters**
+
+#### **Claude Code Adapter (Model Context Protocol & Agent Skills)**
+
+For Claude Code, agent-proof-envelope exposes native Model Context Protocol (MCP) tool endpoints and specialized skill configurations modeled on fallow-skills2. When Claude performs file operations, the MCP server evaluates the output instantly and returns diagnostic feedback directly within the tool execution result block2. Claude receives the exact error code, affected byte range, and auto-fix instructions, prompting the agent to perform immediate self-correction prior to presenting code changes to the user4.
+
+#### **Cursor, Windsurf, and Antigravity Adapter (Native LSP Stream)**
+
+For IDE-integrated agents operating directly over LSP socket connections, agent-proof-envelope acts as an inline language server proxy. Diagnostics are published directly into the editor's diagnostic subsystem, displaying real-time error decorations and fueling inline agent auto-fix prompts immediately upon saving buffer changes.
+
+#### **Aider and OpenAI Codex Adapter (CLI Stdio Interceptor)**
+
+For CLI-based agents like Aider or Codex, agent-proof-envelope hooks into post-command execution wrappers2. If a file edit triggers a Severity 1 diagnostic, the wrapper exits with status code 1 and emits a structured JSON payload to standard error4. The CLI agent ingests the structured diagnostic output, interprets the byte range error, applies the inline patch, and re-validates the codebase automatically.
+
+### **Deterministic Auto-Correction Feedback Loop Protocol**
+
+To ensure sub-second self-correction without triggering infinite agent loops or conversational drift, the governance envelope enforces three operational constraints:
+
+* **Exact Byte-Range Targeting:** Diagnostics must contain precise start and end line/character position coordinates. This prevents agents from rewriting entire source files when repairing localized syntax or logic errors.  
+* **Embedded Refactoring Patches:** Wherever available—such as Ruff auto-fixes, fallow export cleanups, or ast-grep pattern rewrites—the diagnostic envelope includes exact code replacements within the quickFix payload, allowing agents to apply deterministic diffs instantly4.  
+* **Strict Suppression Hygiene:** Agents are strictly forbidden from inserting code suppression comments (e.g., // fallow-ignore-next-line or \# noqa) to bypass errors without explicit user consent4. Any newly introduced suppression marker lacking documented rationale is treated by agent-proof-envelope as a blocking Tier 1 security violation, ensuring absolute adherence to deterministic safety standards4.
+
+#### **Works cited**
+
+> 1. Heretek-AI \- GitHub, [https://github.com/Heretek-AI](https://github.com/Heretek-AI)  
+> 2. GitHub \- fallow-rs/fallow-skills: Agent skills for fallow, codebase intelligence for TypeScript and JavaScript. Teaches AI agents how to find unused code, duplication, circular deps, complexity hotspots, architecture drift, design-system drift, and (with Fallow Runtime) hot-path and cold-path evidence. Works with Claude Code, Cursor, Codex, Gemini CLI, and 30+ agents., [https://github.com/fallow-rs/fallow-skills](https://github.com/fallow-rs/fallow-skills)  
+> 3. "I've never seen anything scarier than an LLM with tool calls." — Erik, [https://finance.biggo.com/podcast/c04647c1eb3be810](https://finance.biggo.com/podcast/c04647c1eb3be810)  
+> 4. GitHub \- fallow-rs/fallow: Codebase intelligence for TypeScript and JavaScript. Free static analysis of code and styles: unused code, duplication, circular deps, complexity hotspots, architecture boundaries, design-system drift. Optional paid runtime layer (Fallow Runtime): hot-path review and cold-path deletion evidence from real production traffic., [https://github.com/fallow-rs/fallow](https://github.com/fallow-rs/fallow)  
+> 5. How to clean up AI-generated code with Fallow \- LogRocket Blog, [https://blog.logrocket.com/clean-ai-code-fallow/](https://blog.logrocket.com/clean-ai-code-fallow/)  
+> 6. tach/Makefile at main · tach-org/tach \- GitHub, [https://github.com/tach-org/tach/blob/main/Makefile](https://github.com/tach-org/tach/blob/main/Makefile)  
+> 7. liberation · GitHub Topics, [https://github.com/topics/liberation?l=javascript](https://github.com/topics/liberation?l=javascript)  
+> 8. \[Testing\] lemonade-cachy-build · Issue \#2471 \- GitHub, [https://github.com/lemonade-sdk/lemonade/issues/2471](https://github.com/lemonade-sdk/lemonade/issues/2471)  
+> 9. cgrep/COMPARISON.md at main · meghendra6/cgrep · GitHub, [https://github.com/meghendra6/cgrep/blob/main/COMPARISON.md](https://github.com/meghendra6/cgrep/blob/main/COMPARISON.md)  
+> 10. Fallow \- Codebase Intelligence · Actions · GitHub Marketplace, [https://github.com/marketplace/actions/fallow-codebase-intelligence](https://github.com/marketplace/actions/fallow-codebase-intelligence)  
+> 11. zizmor \- Static Analysis for GitHub Actions, [https://zizmor.sh/](https://zizmor.sh/)
@@ -85,6 +85,10 @@ export class StackDetector {
      infra.dockerFiles.length +
      agentHarness.files.length;

+    // Universal tools check (ast-grep)
+    const hasAstGrep = this.fileExists('sgconfig.yml') || this.fileExists('.ast-grep.yml');
+    const universal = hasAstGrep ? { hasAstGrep: true } : undefined;
+
    return {
      rootPath: this.rootPath,
      jsTs,
@@ -97,6 +101,7 @@ export class StackDetector {
      ruby,
      elixir,
      infra,
+      universal,
      agentHarness,
      summary: {
        primaryStacks,
@@ -246,11 +251,19 @@ export class StackDetector {
      hasRuffConfig = true;
    }

+    // Check for Tach modular architecture configuration (tach.toml)
+    let hasTach = false;
+    if (this.fileExists('tach.toml') || this.fileExists('.tach.toml')) {
+      hasTach = true;
+      detectedFiles.push('tach.toml');
+    }
+
    return {
      detected: detectedFiles.length > 0,
      files: detectedFiles,
      hasPyproject,
      hasRuffConfig,
+      hasTach,
    };
  }

@@ -449,12 +462,40 @@ export class StackDetector {
      }
    }

+    // Check for Terraform / OpenTofu IaC files
+    let hasTerraform = false;
+    if (this.fileExists('main.tf') || this.fileExists('variables.tf') || this.dirExists('terraform')) {
+      hasTerraform = true;
+    } else {
+      try {
+        const rootEntries = fs.readdirSync(this.rootPath);
+        if (rootEntries.some(f => f.endsWith('.tf') || f.endsWith('.tfvars'))) {
+          hasTerraform = true;
+        }
+      } catch {}
+    }
+
+    // Check for Kubernetes / Helm manifests
+    let hasKubernetes = false;
+    if (this.dirExists('k8s') || this.dirExists('kubernetes') || this.dirExists('helm') || this.fileExists('Chart.yaml')) {
+      hasKubernetes = true;
+    } else {
+      try {
+        const rootEntries = fs.readdirSync(this.rootPath);
+        if (rootEntries.some(f => f.includes('k8s') && (f.endsWith('.yml') || f.endsWith('.yaml')))) {
+          hasKubernetes = true;
+        }
+      } catch {}
+    }
+
    return {
-      detected: workflowFiles.length > 0 || dockerFiles.length > 0,
+      detected: workflowFiles.length > 0 || dockerFiles.length > 0 || hasTerraform || hasKubernetes,
      hasWorkflows: workflowFiles.length > 0,
      workflowFiles,
      hasDocker: dockerFiles.length > 0,
      dockerFiles,
+      hasTerraform,
+      hasKubernetes,
    };
  }

@@ -2,9 +2,9 @@
 * @file src/formatter/diagnosticStream.ts
 * @description LSP-compliant Diagnostic Streaming Engine.
 *
- * Intercepts, deduplicates, and aggregates outputs from all governance tools
- * (AISlop, Biome, Ruff, SkillCheck, TruffleHog, Typos, Actionlint) and formats
- * them into a standardized JSON Diagnostic Envelope ($schema: https://json.schemastore.org/lsif.json).
+ * Intercepts, deduplicates, and aggregates outputs from all compiled governance tools
+ * (AISlop, Biome, Ruff, SkillCheck, TruffleHog, Typos, Actionlint, Zizmor, Hadolint, Tfsec, KubeScore, AST-Grep)
+ * and formats them into a standardized JSON Diagnostic Envelope ($schema: https://json.schemastore.org/lsif.json).
 *
 * Embeds actionable `repair_tokens` enabling autonomous LLM self-correction.
 */
@@ -17,6 +17,10 @@ import { parseSkillcheckOutput } from './parsers/skillcheck.js';
 import { parseTrufflehogOutput } from './parsers/trufflehog.js';
 import { parseTyposOutput } from './parsers/typos.js';
 import { parseActionlintOutput } from './parsers/actionlint.js';
+import { parseZizmorOutput } from './parsers/zizmor.js';
+import { parseHadolintOutput } from './parsers/hadolint.js';
+import { parseTfsecOutput, parseKubeScoreOutput } from './parsers/iac.js';
+import { parseAstGrepOutput } from './parsers/astgrep.js';
 import { parseGenericOutput } from './parsers/generic.js';

 /**
@@ -35,7 +39,7 @@ export interface DiagnosticStreamerOptions {
 * Raw output payload from an individual tool execution
 */
 export interface ToolExecutionResult {
-  /** Identifier of the tool (e.g. 'aislop', 'biome', 'ruff', 'trufflehog') */
+  /** Identifier of the tool (e.g. 'aislop', 'biome', 'ruff', 'zizmor') */
  toolName: string;
  /** Combined stdout and stderr string */
  output: string;
@@ -71,6 +75,21 @@ export class DiagnosticStreamer {
    if (lower.includes('ruff')) {
      return parseRuffOutput(output);
    }
+    if (lower.includes('zizmor')) {
+      return parseZizmorOutput(output);
+    }
+    if (lower.includes('hadolint')) {
+      return parseHadolintOutput(output);
+    }
+    if (lower.includes('tfsec')) {
+      return parseTfsecOutput(output);
+    }
+    if (lower.includes('kube-score') || lower.includes('kubescore')) {
+      return parseKubeScoreOutput(output);
+    }
+    if (lower.includes('ast-grep') || lower.includes('astgrep') || lower === 'sg') {
+      return parseAstGrepOutput(output);
+    }
    if (lower.includes('skill') || lower.includes('skillcheck')) {
      return parseSkillcheckOutput(output);
    }
@@ -147,11 +166,32 @@ export class DiagnosticStreamer {
 export function formatDiagnostics(
  rawOutput: string,
  options: DiagnosticStreamerOptions = {},
-  toolName?: string
+  toolName: string = 'generic'
 ): DiagnosticEnvelope {
-  const effectiveToolName = options.toolName || toolName || 'gate';
-  return DiagnosticStreamer.aggregate(
-    [{ toolName: effectiveToolName, output: rawOutput, exitCode: rawOutput.trim().length > 0 ? 1 : 0 }],
-    options
-  );
+  const effectiveTool = options.toolName || toolName;
+  const items = DiagnosticStreamer.parseToolOutput(effectiveTool, rawOutput);
+  const totalErrors = items.filter(d => d.severity === 'ERROR').length;
+  const totalWarnings = items.filter(d => d.severity === 'WARNING').length;
+
+  return {
+    $schema: 'https://json.schemastore.org/lsif.json',
+    version: '1.0.0',
+    status: totalErrors > 0 ? 'GATE_FAILED' : 'GATE_PASSED',
+    summary: {
+      total_errors: totalErrors,
+      total_warnings: totalWarnings,
+      gate_stage: options.stage || 'PreCommit',
+    },
+    diagnostics: items,
+    metadata: {
+      execution_time_ms: options.executionTimeMs,
+      tool_outputs: {
+        [effectiveTool]: {
+          exitCode: totalErrors > 0 ? 1 : 0,
+          stderr: rawOutput,
+          stdout: '',
+        },
+      },
+    },
+  };
 }
@@ -145,6 +145,9 @@ function detectRuleFromMessage(msg: string = ''): string {
  if (m.includes('dead') || m.includes('unused')) {
    return 'AI_SLOP_DEAD_CODE';
  }
+  if (m.includes('suppress') || m.includes('ts-ignore') || m.includes('noqa') || m.includes('biome-ignore')) {
+    return 'AI_SLOP_UNAUTHORIZED_SUPPRESSION';
+  }
  return 'AI_SLOP_PATTERN_DETECTED';
 }

@@ -200,6 +203,16 @@ function generateAislopRepair(ruleId: string = '', snippet?: string): Diagnostic
    };
  }

+  if (r.includes('SUPPRESS') || r.includes('TS-IGNORE') || r.includes('NOQA')) {
+    return {
+      action: 'REWRITE_BLOCK',
+      description: 'Remove unauthorized suppression comment. Fix the underlying type or lint issue rather than bypassing governance.',
+      repair_tokens: [
+        '// Remove suppression comment and fix root cause with type guards or explicit handling',
+      ],
+    };
+  }
+
  if (r.includes('IMPORT') || r.includes('HALLUCINAT')) {
    return {
      action: 'INSERT_IMPORT',
@@ -0,0 +1,80 @@
+/**
+ * @file src/formatter/parsers/astgrep.ts
+ * @description Parses ast-grep (sg scan) findings into standardized LSP DiagnosticItems.
+ */
+
+import type { DiagnosticItem, DiagnosticSeverity } from '../../types/index.js';
+
+/**
+ * Parse ast-grep output (JSON or line-based) into standardized LSP diagnostic items.
+ *
+ * @param output Raw terminal stdout/stderr from ast-grep / sg
+ * @returns Array of DiagnosticItem objects
+ */
+export function parseAstGrepOutput(output: string): DiagnosticItem[] {
+  const diagnostics: DiagnosticItem[] = [];
+
+  // Attempt JSON parsing first (ast-grep --json)
+  if (output.trim().startsWith('[') || output.trim().startsWith('{')) {
+    try {
+      const parsed = JSON.parse(output);
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (const item of items) {
+        if (item.file && item.ruleId) {
+          diagnostics.push({
+            source: 'ast-grep',
+            rule_id: item.ruleId,
+            severity: (item.severity || 'ERROR').toUpperCase() as DiagnosticSeverity,
+            file_path: item.file,
+            range: item.range
+              ? {
+                  start: { line: item.range.start?.line || 1, column: item.range.start?.column || 1 },
+                  end: { line: item.range.end?.line || 1, column: item.range.end?.column || 80 },
+                }
+              : undefined,
+            error_message: item.message || `ast-grep rule violation: ${item.ruleId}`,
+            repair_instruction: {
+              action: 'REWRITE_BLOCK',
+              description: `Fix AST pattern violation: ${item.ruleId}`,
+              repair_tokens: item.replacement ? [item.replacement] : [`# Fix for ${item.ruleId}`],
+            },
+          });
+        }
+      }
+      if (diagnostics.length > 0) return diagnostics;
+    } catch {}
+  }
+
+  // Fallback to line-based parsing: path/to/file.ts:line:col: [rule-id] message
+  const lines = output.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    const match = trimmed.match(/^([^:]+):(\d+):(\d+):\s*\[?([a-zA-Z0-9_-]+)\]?\s*(.*)$/);
+    if (match) {
+      const [, filePath, lineStr, colStr, ruleId, msg] = match;
+      const lineNum = parseInt(lineStr, 10) || 1;
+      const colNum = parseInt(colStr, 10) || 1;
+
+      diagnostics.push({
+        source: 'ast-grep',
+        rule_id: ruleId,
+        severity: 'ERROR',
+        file_path: filePath,
+        range: {
+          start: { line: lineNum, column: colNum },
+          end: { line: lineNum, column: colNum + 30 },
+        },
+        error_message: msg || `AST pattern violation: ${ruleId}`,
+        repair_instruction: {
+          action: 'REWRITE_BLOCK',
+          description: `Fix AST pattern violation: ${ruleId}`,
+          repair_tokens: [`# Rewrite AST pattern matching ${ruleId}`],
+        },
+      });
+    }
+  }
+
+  return diagnostics;
+}
@@ -0,0 +1,66 @@
+/**
+ * @file src/formatter/parsers/hadolint.ts
+ * @description Parses hadolint Dockerfile static analysis findings into LSP DiagnosticItems.
+ */
+
+import type { DiagnosticItem, DiagnosticSeverity } from '../../types/index.js';
+
+/**
+ * Parse hadolint output (line-based) into standardized LSP diagnostic items with repair tokens.
+ *
+ * @param output Raw terminal stdout/stderr from hadolint
+ * @returns Array of DiagnosticItem objects
+ */
+export function parseHadolintOutput(output: string): DiagnosticItem[] {
+  const diagnostics: DiagnosticItem[] = [];
+  const lines = output.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    // Line format: Dockerfile:line DL3008 warning: Pin versions in apt get install
+    const match = trimmed.match(/^([^:]+):(\d+)\s+([A-Z0-9]+)\s+([a-zA-Z]+):\s*(.*)$/);
+    if (match) {
+      const [, filePath, lineStr, ruleId, severityStr, msg] = match;
+      const lineNum = parseInt(lineStr, 10) || 1;
+      const severity: DiagnosticSeverity = severityStr.toLowerCase() === 'error' ? 'ERROR' : 'WARNING';
+
+      let repairTokens: string[] = [];
+      let repairDesc = `Resolve Dockerfile rule: ${ruleId}`;
+
+      if (ruleId === 'DL3002') {
+        repairDesc = 'Switch to non-root user before executing commands in production container';
+        repairTokens = ['USER node', 'USER 1000:1000'];
+      } else if (ruleId === 'DL3008') {
+        repairDesc = 'Pin package versions when using apt-get install';
+        repairTokens = ['RUN apt-get update && apt-get install -y --no-install-recommends package=1.2.3 && rm -rf /var/lib/apt/lists/*'];
+      } else if (ruleId === 'DL3018') {
+        repairDesc = 'Pin package versions when using apk add';
+        repairTokens = ['RUN apk add --no-cache package=1.2.3'];
+      } else if (ruleId === 'DL3059') {
+        repairDesc = 'Consolidate multiple RUN instructions to reduce container image layers';
+        repairTokens = ['RUN command1 && \\\n    command2'];
+      }
+
+      diagnostics.push({
+        source: 'hadolint',
+        rule_id: ruleId,
+        severity,
+        file_path: filePath,
+        range: {
+          start: { line: lineNum, column: 1 },
+          end: { line: lineNum, column: 80 },
+        },
+        error_message: msg || `Hadolint warning: ${ruleId}`,
+        repair_instruction: {
+          action: 'REWRITE_BLOCK',
+          description: repairDesc,
+          repair_tokens: repairTokens.length > 0 ? repairTokens : [`# Resolve Dockerfile issue: ${ruleId}`],
+        },
+      });
+    }
+  }
+
+  return diagnostics;
+}
@@ -0,0 +1,88 @@
+/**
+ * @file src/formatter/parsers/iac.ts
+ * @description Parses Terraform (tfsec) and Kubernetes (kube-score) static analysis findings into LSP DiagnosticItems.
+ */
+
+import type { DiagnosticItem, DiagnosticSeverity } from '../../types/index.js';
+
+/**
+ * Parse tfsec output into standardized LSP diagnostic items with repair tokens.
+ *
+ * @param output Raw terminal stdout/stderr from tfsec
+ * @returns Array of DiagnosticItem objects
+ */
+export function parseTfsecOutput(output: string): DiagnosticItem[] {
+  const diagnostics: DiagnosticItem[] = [];
+  const lines = output.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    // Line format: path/to/main.tf:12 [HIGH] Description (aws-s3-enable-bucket-encryption)
+    const match = trimmed.match(/^([^:]+):(\d+)\s+\[([A-Z]+)\]\s+(.*?)\s*\(([a-zA-Z0-9_-]+)\)$/);
+    if (match) {
+      const [, filePath, lineStr, severityStr, msg, ruleId] = match;
+      const lineNum = parseInt(lineStr, 10) || 1;
+      const severity: DiagnosticSeverity = ['HIGH', 'CRITICAL', 'ERROR'].includes(severityStr.toUpperCase()) ? 'ERROR' : 'WARNING';
+
+      diagnostics.push({
+        source: 'tfsec',
+        rule_id: ruleId,
+        severity,
+        file_path: filePath,
+        range: {
+          start: { line: lineNum, column: 1 },
+          end: { line: lineNum, column: 80 },
+        },
+        error_message: `${msg} (${ruleId})`,
+        repair_instruction: {
+          action: 'REWRITE_BLOCK',
+          description: `Fix Terraform security misconfiguration: ${ruleId}`,
+          repair_tokens: [`# Apply secure configuration for ${ruleId}`],
+        },
+      });
+    }
+  }
+
+  return diagnostics;
+}
+
+/**
+ * Parse kube-score output into standardized LSP diagnostic items.
+ *
+ * @param output Raw terminal stdout/stderr from kube-score
+ * @returns Array of DiagnosticItem objects
+ */
+export function parseKubeScoreOutput(output: string): DiagnosticItem[] {
+  const diagnostics: DiagnosticItem[] = [];
+  const lines = output.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    // Line format: [CRITICAL] Container Security Context: (container-security-context)
+    const match = trimmed.match(/^\[([A-Z]+)\]\s+(.*?)(?:\s*\((.*?)\))?$/);
+    if (match) {
+      const [, severityStr, msg, ruleId] = match;
+      const severity: DiagnosticSeverity = ['CRITICAL', 'ERROR'].includes(severityStr.toUpperCase()) ? 'ERROR' : 'WARNING';
+      const id = ruleId || 'KUBE_SCORE_SECURITY';
+
+      diagnostics.push({
+        source: 'kube-score',
+        rule_id: id,
+        severity,
+        file_path: 'k8s/manifest.yaml',
+        error_message: msg,
+        repair_instruction: {
+          action: 'REWRITE_BLOCK',
+          description: `Resolve Kubernetes security finding: ${msg}`,
+          repair_tokens: ['securityContext:\n  readOnlyRootFilesystem: true\n  runAsNonRoot: true\n  allowPrivilegeEscalation: false'],
+        },
+      });
+    }
+  }
+
+  return diagnostics;
+}
@@ -0,0 +1,79 @@
+/**
+ * @file src/formatter/parsers/zizmor.ts
+ * @description Parses zizmor GitHub Actions workflow security audit findings into LSP DiagnosticItems.
+ */
+
+import type { DiagnosticItem, DiagnosticSeverity } from '../../types/index.js';
+
+/**
+ * Parse zizmor output (line-based or JSON) into standardized LSP diagnostic items with repair tokens.
+ *
+ * @param output Raw terminal stdout/stderr from zizmor
+ * @returns Array of DiagnosticItem objects
+ */
+export function parseZizmorOutput(output: string): DiagnosticItem[] {
+  const diagnostics: DiagnosticItem[] = [];
+  const lines = output.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    // Line format: path/to/workflow.yml:line:col: [rule-name] message
+    const match = trimmed.match(/^([^:]+):(\d+):(\d+):\s*\[?([a-zA-Z0-9_-]+)\]?\s*(.*)$/);
+    if (match) {
+      const [, filePath, lineStr, colStr, ruleId, msg] = match;
+      const lineNum = parseInt(lineStr, 10) || 1;
+      const colNum = parseInt(colStr, 10) || 1;
+
+      let repairTokens: string[] = [];
+      let repairDesc = `Fix GitHub Actions security issue: ${ruleId}`;
+
+      if (ruleId.includes('unpinned-uses') || msg.includes('unpinned')) {
+        repairDesc = 'Pin GitHub Action by full 40-character commit SHA rather than tag';
+        repairTokens = ['uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1'];
+      } else if (ruleId.includes('template-injection') || msg.includes('injection')) {
+        repairDesc = 'Sanitize context expressions by assigning to env variables rather than inline script templates';
+        repairTokens = ['env:\n  USER_INPUT: ${{ github.event.issue.title }}'];
+      } else if (ruleId.includes('excessive-permissions') || msg.includes('permissions')) {
+        repairDesc = 'Set least-privilege workflow permissions';
+        repairTokens = ['permissions:\n  contents: read'];
+      }
+
+      diagnostics.push({
+        source: 'zizmor',
+        rule_id: ruleId,
+        severity: 'ERROR',
+        file_path: filePath,
+        range: {
+          start: { line: lineNum, column: colNum },
+          end: { line: lineNum, column: colNum + 20 },
+        },
+        error_message: msg || `Zizmor security warning: ${ruleId}`,
+        repair_instruction: {
+          action: 'REWRITE_BLOCK',
+          description: repairDesc,
+          repair_tokens: repairTokens.length > 0 ? repairTokens : [`# Security fix for ${ruleId}`],
+        },
+      });
+    }
+  }
+
+  // If no line matches found but output indicates failure, emit summary
+  if (diagnostics.length === 0 && output.toLowerCase().includes('error')) {
+    diagnostics.push({
+      source: 'zizmor',
+      rule_id: 'ZIZMOR_SECURITY_ALERT',
+      severity: 'ERROR',
+      file_path: '.github/workflows',
+      error_message: output.slice(0, 300),
+      repair_instruction: {
+        action: 'MANUAL_FIX',
+        description: 'Resolve GitHub Actions workflow security warnings reported by zizmor.',
+        repair_tokens: ['# Audit and harden GitHub Actions workflow permissions and action SHAs'],
+      },
+    });
+  }
+
+  return diagnostics;
+}
@@ -4,6 +4,7 @@
 *
 * Enforces zero-tolerance rules for AI code smells:
 * - Swallowed errors and empty catch blocks
+ * - Unauthorized suppression comments (Suppression Hygiene)
 * - Unsafe type casts (as any)
 * - Hallucinated imports
 * - Insecure YAML deserialization (yaml.load without SafeLoader)
@@ -13,7 +14,7 @@

 /**
 * Generate an AISlop configuration defining deterministic rules against
- * swallowed errors, empty catch blocks, hallucinated imports, and unsafe patterns.
+ * swallowed errors, empty catch blocks, hallucinated imports, unauthorized suppressions, and unsafe patterns.
 *
 * @returns Formatted YAML string for .aislop/config.yml
 */
@@ -35,6 +36,12 @@ rules:
    fail_score: 25
    enabled: true

+  # Strict suppression hygiene: forbid blind suppression comments (@ts-ignore, # noqa)
+  unauthorized_suppressions:
+    severity: error
+    fail_score: 50
+    enabled: true
+
  # Hallucinated or non-existent imports
  hallucinated_imports:
    severity: error
@@ -56,6 +56,22 @@ export function generateClaudeHooksConfig(detection: StackDetectionResult): stri
    });
  }

+  // Workflows: Fast GitHub Actions static security analysis via zizmor
+  if (detection.infra.hasWorkflows) {
+    postFileEditRules.push({
+      matcher: '.github/workflows/*.{yml,yaml}',
+      command: 'if command -v zizmor >/dev/null 2>&1; then zizmor ${filePath}; fi',
+    });
+  }
+
+  // Containers: Fast Dockerfile static analysis via hadolint
+  if (detection.infra.hasDocker) {
+    postFileEditRules.push({
+      matcher: '{Dockerfile*,Containerfile*}',
+      command: 'if command -v hadolint >/dev/null 2>&1; then hadolint ${filePath}; fi',
+    });
+  }
+
  // Skill files: Validate agent skills against schema and OWASP agentic boundaries
  postFileEditRules.push({
    matcher: '.claude/skills/*.md',
@@ -4,7 +4,7 @@
 *
 * Implements:
 * - Stage 2: Synchronous Local Pre-Commit Hard Gates (< 2.0s execution target)
- *   Runs parallel native binaries across staged files (Biome, Ruff, AISlop, TruffleHog, Typos, Actionlint)
+ *   Runs compiled native binaries across staged files (Biome, Ruff, Tach, ast-grep, AISlop, TruffleHog, Typos, Actionlint, Zizmor, Hadolint, Tfsec, Kube-Score)
 * - Stage 3: CI & Codebase Graph Governance
 *   Runs deep analysis (Fallow, Sherif, OWASP Noir, Cargo Deny) during pre-push or CI.
 */
@@ -37,6 +37,10 @@ export function generateLefthookConfig(detection: StackDetectionResult): string
    preCommitCommands.push(`    ruff-check:
      glob: "*.py"
      run: ruff check --staged --fix`);
+
+    preCommitCommands.push(`    tach-check:
+      glob: "*.py"
+      run: if command -v tach >/dev/null 2>&1; then tach check; fi`);
  }

  // Go: Fast static security analysis via gosec
@@ -88,6 +92,10 @@ export function generateLefthookConfig(detection: StackDetectionResult): string
      run: if command -v mix >/dev/null 2>&1; then mix credo --strict {staged_files}; fi`);
  }

+  // Universal: Fast structural AST search and rewriting via ast-grep
+  preCommitCommands.push(`    ast-grep-scan:
+      run: if command -v sg >/dev/null 2>&1; then sg scan; elif command -v ast-grep >/dev/null 2>&1; then ast-grep scan; fi`);
+
  // Universal: Fast deterministic AI slop and swallowed error detection
  preCommitCommands.push(`    aislop-scan:
      run: if command -v aislop >/dev/null 2>&1; then aislop scan --staged; fi`);
@@ -100,11 +108,36 @@ export function generateLefthookConfig(detection: StackDetectionResult): string
  preCommitCommands.push(`    typo-check:
      run: if command -v typos >/dev/null 2>&1; then typos --staged; fi`);

-  // Infra: GitHub Actions workflow syntax validation via actionlint
+  // Infra: GitHub Actions workflow syntax & security validation via actionlint & zizmor
  if (detection.infra.hasWorkflows) {
    preCommitCommands.push(`    actionlint:
      glob: ".github/workflows/*.{yml,yaml}"
      run: if command -v actionlint >/dev/null 2>&1; then actionlint; fi`);
+
+    preCommitCommands.push(`    zizmor-audit:
+      glob: ".github/workflows/*.{yml,yaml}"
+      run: if command -v zizmor >/dev/null 2>&1; then zizmor .github/workflows; fi`);
+  }
+
+  // Infra: Docker / Container security validation via hadolint
+  if (detection.infra.hasDocker) {
+    preCommitCommands.push(`    hadolint-check:
+      glob: "{Dockerfile*,Containerfile*,docker-compose*.{yml,yaml}}"
+      run: if command -v hadolint >/dev/null 2>&1; then hadolint {staged_files}; fi`);
+  }
+
+  // Infra: Terraform / OpenTofu IaC static security analysis via tfsec
+  if (detection.infra.hasTerraform) {
+    preCommitCommands.push(`    tfsec-check:
+      glob: "*.{tf,tfvars}"
+      run: if command -v tfsec >/dev/null 2>&1; then tfsec .; fi`);
+  }
+
+  // Infra: Kubernetes static security analysis via kube-score
+  if (detection.infra.hasKubernetes) {
+    preCommitCommands.push(`    kube-score-check:
+      glob: "{k8s/**,kubernetes/**,*.k8s.{yml,yaml}}"
+      run: if command -v kube-score >/dev/null 2>&1; then kube-score score {staged_files}; fi`);
  }

  // =========================================================================
@@ -42,6 +42,8 @@ export interface StackDetectionResult {
    hasPyproject: boolean;
    /** True if Ruff configuration is defined in ruff.toml or pyproject.toml */
    hasRuffConfig: boolean;
+    /** True if Tach architecture boundary configuration (tach.toml) is present */
+    hasTach?: boolean;
  };

  /** Go ecosystem detection details */
@@ -114,6 +116,16 @@ export interface StackDetectionResult {
    hasDocker: boolean;
    /** List of relative paths to Docker / container definition files */
    dockerFiles: string[];
+    /** True if Terraform / OpenTofu IaC files (*.tf) are present */
+    hasTerraform?: boolean;
+    /** True if Kubernetes manifests or Helm charts are present */
+    hasKubernetes?: boolean;
+  };
+
+  /** Universal tools detection */
+  universal?: {
+    /** True if ast-grep configuration (sgconfig.yml) is present */
+    hasAstGrep?: boolean;
  };

  /** AI agent harness, skill definitions, and configuration files */
@@ -189,4 +189,21 @@ members = ["crates/*"]
    expect(result.summary.primaryStacks).toContain('Ruby');
    expect(result.summary.primaryStacks).toContain('Elixir');
  });
+
+  it('detects Docker, Terraform, Kubernetes, Tach, and ast-grep tools', () => {
+    fs.writeFileSync(path.join(tempDir, 'Dockerfile'), 'FROM node:22-alpine');
+    fs.writeFileSync(path.join(tempDir, 'main.tf'), 'resource "aws_s3_bucket" "b" {}');
+    const k8sDir = path.join(tempDir, 'k8s');
+    fs.mkdirSync(k8sDir, { recursive: true });
+    fs.writeFileSync(path.join(k8sDir, 'deployment.yaml'), 'apiVersion: apps/v1');
+    fs.writeFileSync(path.join(tempDir, 'tach.toml'), '[[modules]]');
+    fs.writeFileSync(path.join(tempDir, 'sgconfig.yml'), 'ruleDirs: [rules]');
+
+    const result = detectStack(tempDir);
+    expect(result.infra.hasDocker).toBe(true);
+    expect(result.infra.hasTerraform).toBe(true);
+    expect(result.infra.hasKubernetes).toBe(true);
+    expect(result.python.hasTach).toBe(true);
+    expect(result.universal?.hasAstGrep).toBe(true);
+  });
 });
@@ -162,4 +162,43 @@ src/api.py:25:5: E722 Do not use bare 'except'`;
    expect(envelope.summary.total_errors).toBe(0);
    expect(envelope.diagnostics.length).toBe(0);
  });
+
+  it('formats zizmor workflow security findings', () => {
+    const raw = `.github/workflows/deploy.yml:24:9: [unpinned-uses] unpinned action usage`;
+    const envelope = formatDiagnostics(raw, { toolName: 'zizmor' });
+
+    expect(envelope.status).toBe('GATE_FAILED');
+    expect(envelope.diagnostics[0].source).toBe('zizmor');
+    expect(envelope.diagnostics[0].rule_id).toBe('unpinned-uses');
+    expect(envelope.diagnostics[0].file_path).toBe('.github/workflows/deploy.yml');
+    expect(envelope.diagnostics[0].repair_instruction?.repair_tokens[0]).toContain('actions/checkout@');
+  });
+
+  it('formats hadolint Dockerfile static analysis errors', () => {
+    const raw = `Dockerfile:10 DL3008 warning: Pin versions in apt get install`;
+    const envelope = formatDiagnostics(raw, { toolName: 'hadolint' });
+
+    expect(envelope.status).toBe('GATE_PASSED'); // warning severity
+    expect(envelope.diagnostics[0].source).toBe('hadolint');
+    expect(envelope.diagnostics[0].rule_id).toBe('DL3008');
+    expect(envelope.diagnostics[0].repair_instruction?.repair_tokens[0]).toContain('apt-get install');
+  });
+
+  it('formats tfsec IaC security violations', () => {
+    const raw = `terraform/main.tf:15 [HIGH] S3 Bucket Encryption disabled (aws-s3-enable-bucket-encryption)`;
+    const envelope = formatDiagnostics(raw, { toolName: 'tfsec' });
+
+    expect(envelope.status).toBe('GATE_FAILED');
+    expect(envelope.diagnostics[0].source).toBe('tfsec');
+    expect(envelope.diagnostics[0].rule_id).toBe('aws-s3-enable-bucket-encryption');
+  });
+
+  it('formats suppression hygiene violations in AISlop', () => {
+    const raw = `src/auth.ts:12:1: [AI_SLOP_UNAUTHORIZED_SUPPRESSION] Unauthorized @ts-ignore suppression comment`;
+    const envelope = formatDiagnostics(raw, { toolName: 'aislop' });
+
+    expect(envelope.status).toBe('GATE_FAILED');
+    expect(envelope.diagnostics[0].rule_id).toBe('AI_SLOP_UNAUTHORIZED_SUPPRESSION');
+    expect(envelope.diagnostics[0].repair_instruction?.action).toBe('REWRITE_BLOCK');
+  });
 });
@@ -42,12 +42,15 @@ describe('ConfigGenerator', () => {
    expect(yaml).toContain('parallel: true');
    expect(yaml).toContain('biome check --staged');
    expect(yaml).toContain('ruff check --staged --fix');
+    expect(yaml).toContain('tach check');
    expect(yaml).toContain('gosec -quiet ./...');
    expect(yaml).toContain('cargo deny check');
+    expect(yaml).toContain('ast-grep');
    expect(yaml).toContain('aislop scan --staged');
    expect(yaml).toContain('trufflehog git file://. --staged --only-verified');
    expect(yaml).toContain('typos --staged');
    expect(yaml).toContain('actionlint');
+    expect(yaml).toContain('zizmor');

    // Stage 3 (Pre-Push / CI) assertions
    expect(yaml).toContain('pre-push:');