vibes ✨

The Living Showcase, Open Collection & Artifact Repository of Agentic Software Engineering

"Vibe coding" was coined to describe casual, prompt-and-pray programming. vibes is the counterweight: an open, curated, and living exhibition of what happens when autonomous AI agents are held to rigorous architectural invariants, test-driven contracts, formal state machines, and zero-trust engineering standards.

TLDR: vibes is an open-source exhibition and living laboratory showcasing rigorous, test-driven, and invariant-gated agentic software engineering as the professional counterweight to casual "vibe coding".

ELI:7b: This repository is a museum and playground showing how to make AI coders reliable by giving them strict rules, automated tests, and safety guardrails, instead of just crossing your fingers and hoping the AI gets it right.

---

🏛️ Welcome to the Exhibition

vibes is an open-source repository designed to serve as a showpiece, educational laboratory, and living archive for the emergent discipline of agentic software engineering.

Here you will find:

1. Empirical Field Observations: Concrete, battle-tested case studies detailing how autonomous agents behave, fail, adapt, and succeed when building production software (headlined by the development of devops-cli).
2. Autonomous Engineering Patterns: Practical architectural strategies—from Counterexample-Guided Inductive Synthesis (CEGIS) to FIFO Pull Request Shepherding and Self-Hardening Instructions.
3. Inspectable Artifacts: Verifiable prompt harnesses, FastMCP schema manifests, multi-persona review systems, and structured task specifications used by agents in production.
4. Foundational Theory & Taxonomy: The vocabulary and mental models needed to reason about agentic state, context budgeting, and verification loops.
5. Living Agent Instructions (AGENTS.md): A gold-standard instruction framework enabling autonomous agents to read, curate, and contribute new findings to this repository without human hand-holding.
6. The Dummy's Guide to Agentic Engineering: Core fundamentals explained in plain English without technical mumbo jumbo, complete with "TLDR" and "ELI:7b" header summaries.
7. Empirical Foundations & Critical Synthesis: Peer-reviewed external scientific grounding, counter-evidence analysis, and code samples examining where invariants succeed and where they break down.

---

🔬 Featured Case Study: The devops-cli Laboratory

The headline exhibition in vibes is drawn from the autonomous development of devops-cli—a complex, multi-cloud, container-orchestrating, AI-integrated developer CLI built with over 900 automated tests, strict $\ge 90.0%$ test coverage, and 10 continuous CI quality gates.

🧭 Master Observation Index: For the comprehensive cross-domain synthesis and comparative matrix of all 76 case studies, see Consolidated Field Observations & Architectural Synthesis.

Exhibition Piece	Core Observation & Breakthrough
01. TDD as Living Contract	How writing executable tests first converts stochastic LLM tokens into deterministic engineering progress.
02. Architectural Invariants & Complexity Caps	Enforcing AST-verified cyclomatic complexity $\le 10$ and nesting $\le 5$ to prevent the "spaghetti generation" trap.
03. Autonomous Project Governance	Eliminating agent amnesia and drift by grounding every turn in GitHub Projects v2, atomic issues, and WIP states.
04. Zero-Trust Egress & Sanitization	Eliminating homelab IP leaks, private paths, and secrets through automated sanitizers and RFC dummy standards.
05. Harness Slots & Sub-Agent Offloading	"Big decides, small types, big checks": Partitioning reasoning vs. symbol extraction to slash token overhead by 85%+.
06. Rate Limits & Anti-Brittle Heuristics	Surviving API quotas with client-side token buckets and strictly prohibiting arbitrary partial pattern matches.
07. Proactive Headroom & Recursive Feedback Loops	Why hard caps are insufficient: using headroom analysis and automated SDLC backlog export to self-remediate before hitting invariant ceilings.
08. Closed-Loop Feedback Inversion & Autonomous Quality Elevation	How clearing high-priority blockers automatically inverts agent focus from reactive bug-fixing to proactive contract completion (100% docstring coverage).
09. Mechanical AST Rewriting & Automated Refactoring Convergence	Deterministic structural refactoring (table dispatch, guard flattening, predicate extraction) consuming SDLC feedback to eliminate complexity traps without LLM hallucination.
10. Negative Tool Contract Assertions & Prescriptive Prompt Synthesis	Eliminating agent parameter hallucination through JSON Schema negative assertions (additionalProperties: false) and prescriptive error prompts enabling zero-shot recovery.
11. Assertion Density & Structural Tuple Consolidation	Resolving test suite cyclomatic complexity traps ($M \le 10$) by consolidating linear assertion sprawl into structural tuple equality checks without loss of pytest diagnostics.
12. Polyglot CST Boundary Guards & Symlink Containment	Eliminating OOM crashes and circular symlink loops (ELOOP) during multi-language AST crawling with pre-flight file size caps ($\le 5$MB) and workspace boundary verification.
21. Milestone Horizon Expansion & Scope Cascades	Resolving the Milestone Horizon Inflation Trap and release live-locks with mathematical convergence tracking ($C_R \ge 1.2$) and three-phase release air-lock governance.
22. The Verification Horizon & Validation Latency Cliffs	Resolving the verification horizon trap where expanding test suites starve agent working memory via a tiered verification pyramid and sub-second feedback oracles.

---

---

🔬 Polyglot & Systems Case Studies

Agentic coding manifests differently across languages, compiler architectures, and infrastructure topologies:

Exhibition Piece	Domain & Focus	Core Observation
Rust Type-State Invariants	Rust (Affine Types)	How the type-state pattern and zero-sized marker types eliminate 90%+ invalid state bugs at compile time.
TypeScript CST & Type Gymnastics	TypeScript (CST & Generics)	Taming deep conditional types and enforcing zero-any / zero-@ts-ignore invariant gates.
Go Goroutine Leakage & Context Lifecycles	Go Concurrency & Memory	Diagnosing orphaned goroutines, unbuffered channel deadlocks, and leaking context lifecycles via runtime stack analysis.
Distributed Telemetry & Agent Waterfalls	Distributed Systems (OTel)	Eliminating the agent black box with W3C traceparent propagation, semantic tokens, and waterfall analysis.
Subprocess Test Harness Instrumentation Tax	Systems & DevEx	How unpruned workspace test plugins (xdist/cov/logfire) create 10x latency traps in iterative agent feedback loops, and how selective bypass restores sub-second velocity.
Event-Driven File Watchers & Continuous Invariant Loops	Systems & DevEx	Pure standard-library file watching and subprocess flag optimization providing sub-second change detection and continuous delta telemetry.
Content-Addressed Caching & Embedding Drift Audits	Distributed Caching & Math	Content-addressed SHA-256 caching (L1 memory + L2 Valkey RESP) and 8-dimensional structural embedding cosine distance ($D_C \le 0.05$) drift verification.
Rootless Container Sandboxing & Process Group Containment	Container Security & POSIX	Hardened rootless container execution with 100% CIS benchmark compliance, POSIX process group isolation (os.setsid/os.killpg), and bounded stream buffers.
Multi-Agent Concurrency & Workspace Hazards	Concurrency & Swarm Dynamics	Eliminating working tree clobbering, SQLite coverage DB unlinking corruption, and cascading rebase live-locks with git worktrees, scoped data tiers, and FIFO PR shepherding.
Agentic Project Self-Documentation	Systems & Governance	Resolving the dual-audience paradox and the phantom architecture trap with a 4-tier living documentation architecture.
Post-Harness Recursive Self-Improvement	Systems & Governance	Establishing the operational mandate for recursive self-improvement and scaling laws via asymmetric invariant verification ($P$ vs $NP$) and outward landscape telemetry.
Epistemic Drift & The Unreliable Teacher	Multi-Agent Verification	Resolving mitigation-refutation conflation and catalog self-contamination with tripartite verification and immutable epistemic seams.
Kinetic Falsification & Exploit Harnesses	Verification & Security	Replacing rhetorical verifier debate with minimal executable counterexample probes in micro-sandboxes, evaluating OS exit codes as ground truth.
Instruction Ratchet Bloat & JIT Ablation	Context & Governance	Resolving monolithic prompt bloat and lost-in-the-middle attention decay with two-tier JIT prompt envelopes and empirical counterfactual ablation.
Differential Polyglot AST Mutation Fuzzing	Polyglot (Boundary Testing)	Grammatical mutation fuzzing evaluating parser convergence, symlink escape detection, and memory leak isolation.
Typed Epistemic Seams & Subagent Handshakes	Multi-Agent Epistemics	Eliminating delegation drift with content-addressed invariant envelopes and negative schema enforcement.
eBPF LSM Kernel Gates & Dynamic Containment Fuzzing	Kernel Security & Invariants	Synchronous pre-execution denial (-EPERM), zero race windows, and dynamic Syzkaller boundary fuzzing for agent sandboxes.
3-Way AST Semantic Reconciliation & Collision Arbitration	Multi-Agent Concurrency & Git	Commutative AST symbol reconciliation eliminating line-based false merge conflicts across concurrent subagent worktrees.
WASI Component Models & Capability-Based Tool Sandboxing	Systems & Runtime Sandboxing	Sub-millisecond tool execution ($< 500\mu\text{s}$) with unforgeable object capabilities, deterministic gas metering, and zero ambient UNIX authority.
Real-Time AST-CRDTs & Multi-Agent Swarms	Multi-Agent Concurrency & CRDTs	Eliminating character-level syntax errors (34.2% -> 0.0%) with replicated AST nodes, Lamport clocks, and fractional ordering.
Graph-Ranked AST Context Optimizer	Context & Graph Centrality	Personalized PageRank over AST symbol graphs eliminating prompt pollution and mid-block syntax fractures.
Contract-Driven Template Ecosystems & In-Place Updates	Systems & Application Scaffolding	Decoupling contract boundaries from hand-written domain logic via AST reconciliation, eliminating destructive regenerations and interface drift.
Polyglot Token Normalization & Clone Quantification	Systems & Smell Quantification	Zero-dependency Type-2 regex token normalization and cross-language clone detection with normalized MI metrics, closing the final open build gap.
Sycophantic Compliance & Mechanical Refusal Oracles	Systems & Agent Alignment	Halting architectural collapse and test erasure caused by LLM agreeableness through deterministic mechanical refusal oracles.
Closed-Loop PR Review Thread Synchronization	Agent Orchestration & Review Lifecycle	Grounding review comments in AST symbols, mechanically verifying defect resolution, and synthesizing atomic GraphQL mutations with SARIF telemetry.
Biological Autopoiesis & Homeostatic Damping	Systems Biology & Observability	Transforming passive observability into afferent sensory feedback, damping hyper-metabolic churn via hysteresis deadbands, and enforcing cellular apoptosis.

---

🛠️ Reusable Engineering Patterns

Proven patterns distilled from hundreds of hours of autonomous agent sessions:

flowchart TD
    A[User Request / Defect] --> B[CEGIS: Formulate Falsifiable Hypothesis]
    B --> C[Author Failing Counterexample Test]
    C --> D[Autonomous Patch Synthesis]
    D --> E{CI & Invariant Gates}
    E -- Fail --> C
    E -- Pass --> F[Root-Cause Remediation]
    F --> G[Self-Hardening: Update AGENTS.md]
    G --> H[FIFO Pull Request Shepherding]

Loading

• CEGIS & Hypothesis Debugging: Why single-shot bug fixing fails, and how counterexample-guided inductive synthesis forces convergence on minimal diffs.
• FIFO Pull Request Shepherding: How chronological queue processing eliminates cascading merge conflicts and PR starvation in agent swarms.
• Root-Cause Hardening: The self-updating instruction loop—never fixing a bug in code without updating AGENTS.md to prevent recurrence.
• Epistemic Hygiene & Context Pruning: Human-like cognitive information foraging, multi-scale outlines, and bounded string caps ($\le 256$ chars).
• Zero-Trust Sandboxing & Distributed Observability: Defense-in-depth pairing rootless, capability-dropped sandboxes and SSRF egress blocking with real-time OTLP span streaming.
• Adaptive Headless Web Crawling: Two-tier dynamic escalation, SPA shell detection, noise/modal pruning, and persistent domain strategy memory.
• Autonomous SDLC Project Management: Deterministic multi-dimensional prioritization, dependency graph cycle analysis, and prescriptive agent next-action dispatch.
• Iterative Resource Refinement Loop: Closed-loop Scan -> Run -> Review -> Feedback -> Iterate engine generating actionable improvement feedback, backlog tasks, and delta tracking before commit.
• Deterministic Mechanical Oracles & Feedback Inversion: Binding stochastic LLM tokens to mechanical invariant gates (table dispatch, structural tuple assertions, negative tool schemas, process groups, boundary caps) and inverting feedback from reactive bug-fixing to proactive headroom elevation.
• Multi-Agent Codebase Concurrency: Architectural spatial isolation, partitioned data tiers, and centralized resource arbitration enabling collision-free multi-agent swarm collaboration on a single codebase.
• Multi-Tier Living Documentation: Decoupling deterministic AST extraction from constrained generative narrative synthesis, backed by fail-closed oracles and active compaction.
• Invariant-Grounded Recursive Self-Improvement: Transforming autonomous evolution from unconstrained generative drift into a convergent, closed-loop engine bounded by deterministic AST sentinels, CEGIS constraint sets, and outward telemetry.
• Epistemic Seam & Mitigated Defect Auditing: Eliminating silent defect drops and catalog drift by separating refutation from mitigation and restricting negative catalog learning to ground truth.
• Kinetic Exploit Probes & Invariant Leashing: Replacing rhetorical verifier debate with executable counterexample probes in micro-sandboxes, paired with invariant leashes tracking perimeter dependencies.
• Just-In-Time Instruction Decomposition & Ablation: Eliminating instruction ratchet bloat and lost-in-the-middle attention degradation with a two-tier JIT prompt governor, rule attribution matrix, and counterfactual ablation.
• Collision-Free Worktree Fleet Allocation: Ephemeral leased git worktrees with bounded TTL, jittered lock polling, POSIX process group containment, and automated stale pruning.
• Synthetic Chaos & Invariant Convergence Testing: Deterministic chaos injection perturbing mechanical invariants with rollback safety and automated repair ratio telemetry.
• Kernel-Enforced LSM Sandbox Containment: Synchronous pre-execution denial (-EPERM) at the BPF LSM boundary with dynamic Syzkaller boundary fuzzing and declarative Tetragon policy compilation.
• 3-Way AST Semantic Reconciliation: Decomposing source files into commutative symbol graphs to eliminate line-based false merge conflicts across concurrent agent worktrees.
• Capability-Based Wasm Sandboxing: Executing untrusted agent tools inside WebAssembly components governed by unforgeable capability tokens, deterministic gas metering, and linear memory containment.
• AST-CRDTs for Real-Time Agent Collaboration: Replicating Abstract Syntax Tree nodes as first-class distributed entities with Lamport timestamps, fractional positioning, and deterministic cycle prevention.
• AST Graph Relevance Ranking & Context Packing: Personalizing random walks over AST symbol graphs to pack maximal architectural context into tight token budgets with zero syntax fractures.
• Contract Template Ecosystem and In-Place Updates: Decoupling contract layer schemas and dispatch tables from hand-written domain logic with AST-reconciled in-place upgrades and automatic stub synthesis.
• Polyglot Token Normalization and Clone Quantification: Language-agnostic Type-2 token normalization erasing identifiers and literals to generic placeholders, computing cross-language clone detection and normalized Maintainability Index without native compiler dependencies.
• Milestone Scope Air-Lock & Triage Ratchet Governance: Three-phase milestone lifecycle ratchet (INTAKE → AIR_LOCKED → FROZEN) with mathematical convergence ratio gates ($C_R \ge 1.2$) and automated rollover partitioning to eliminate release live-locks.
• Tiered Verification Pyramid & Sub-Second Oracles: Tiered testing hierarchy partitioning fast in-memory checks from full regression suites, providing sub-second feedback oracles and structural tuple equality assertions to prevent agent working memory exhaustion.
• Sycophantic Compliance & Mechanical Refusal: Decoupling refusal authority from stochastic model psychology using deterministic AST sentinels, negative schema contracts, immutable coverage floors, and network air-gaps.
• Closed-Loop PR Review Thread Synchronization: Grounding PR review comments in semantic AST symbols, mechanically verifying fixes against deterministic invariant oracles, and synthesizing atomic reply-and-resolve GraphQL mutations with OASIS SARIF 2.1.0 telemetry.

---

📜 The Disciplined Agentic Manifesto & Retrospective

What separates unstructured prompt tinkering from serious agentic engineering? Read the full Manifesto and Retrospective Analysis:

1. Tests are Executable Contracts, Not Afterthoughts.
2. Architectural Invariants Must Be Mechanically Enforced.
3. Zero Zombie Code & Clean Solutions Over Legacy Remnants.
4. Grounded Project Tracking (Zero Invisible Agent Actions).
5. Self-Healing Instructions (Fix Root Causes, Not Symptoms).
6. Invariant-Grounded Recursive Self-Improvement & Continuous Co-Evolution.
7. The Sovereign Human Core & Autonomous Invariant Discovery.

---

💻 Executable Sample Applications (examples/)

Runnable reference implementations demonstrating core agentic engineering mechanics in action. Sample apps stay close to the standard library so a reader can copy one file and run it; the repository's own tooling under tools/ adopts established open source instead, per the dependency policy in AGENTS.md:

Sample Application	Mechanics Demonstrated	Automated Test Suite
AST Invariant Sentinel	Python AST NodeVisitor measuring cyclomatic complexity ($M \le 10$), nesting depth ($\le 5$), and RFC 5737 zero-trust IP sanitization.	pytest test_sentinel.py
FastMCP Token-Bucket Gateway	Client-side rate limiter and tool dispatcher with burst capacity, token refills, and jittered backoff protecting external APIs.	pytest test_gateway.py
CEGIS Debugging Workbench	Formal Counterexample-Guided Inductive Synthesis loop accumulating negative constraints to converge on minimal atomic patches.	pytest test_workbench.py
Agent Waterfall Trace Generator	OpenTelemetry distributed trace generator rendering ASCII waterfalls and tracking token spend across model tiers.	pytest test_generator.py
Adaptive Web Crawler	Two-tier adaptive crawler detecting SPA shells, escalating to headless browsing, persisting learned domain strategies, and emitting Markdown shaped for a prompt — fenced code, resolved links, escaped page text.	pytest examples/adaptive-web-crawler/
Prompt Mutation Fuzzer	Grammar-guided prompt perturbation and multi-provider model driver (Mock, OpenAI, Anthropic, Ollama, REST) evaluating agent code invariant resilience.	pytest examples/prompt-mutation-fuzzer/test_fuzzer.py
Tool Contract Verifier	Formal JSON Schema Draft 2020-12 verification gate enforcing negative assertions against hallucinated parameters, type mismatches, and bounded string caps.	pytest examples/tool-contract-verifier/test_verifier.py
Valkey L2 Repomap Cache & Drift Auditor	High-throughput two-tier AST symbol caching with RESP protocol, content SHA-256 addressing, and cosine distance semantic drift auditing.	pytest examples/valkey-l2-repomap-cache/test_repomap_cache.py
Ephemeral Container Sandbox	Hardened rootless container sandbox with CIS benchmark auditing, egress deny-all isolation, and a container-less fallback confined by an unprivileged seccomp-BPF filter. Reports what the engine enforces beside what the policy declares.	pytest examples/ephemeral-container-sandbox/
Polyglot CST Ingestion Engine	Multi-language CST parser (Python, Rust, Go, TS, Bash) with language-agnostic complexity ($M$) and pre-flight boundary guards.	pytest examples/polyglot-cst-parser/test_cst_parser.py
Go Goroutine Leak Sentinel	Go concurrency leak harness and runtime trace analyzer detecting unbuffered channel hangs, abandoned contexts, and orphan goroutines.	pytest examples/go-leak-sentinel/test_go_leak_sentinel.py
Agent Experience Evaluator	Static analysis measuring agent usability, cognitive impedance ($M \le 6$, depth $\le 3$), and strict negative tool schemas with SARIF export.	pytest examples/agent-experience-evaluator/test_ax_evaluator.py
Differential Polyglot Mutation Fuzzer	Grammatical AST fuzzer evaluating parser resilience, boundary depth, and ELOOP symlink loop containment.	pytest examples/polyglot-mutation-fuzzer/test_polyglot_fuzzer.py
Worktree Swarm Arbiter	Ephemeral git worktree fleet broker with lease heartbeats, index lock contention mitigation, and process group isolation.	pytest examples/worktree-swarm-arbiter/test_worktree_arbiter.py
Typed Context Handshake	Cryptographically content-addressed context envelope protocol with negative schema enforcement and epistemic loss auditing.	pytest examples/epistemic-context-handshake/test_context_handshake.py
Chaos Invariant Injector	Deterministic chaos engineering engine perturbing complexity, nesting, and egress invariants to benchmark self-healing.	pytest examples/chaos-invariant-monkey/test_chaos_monkey.py
eBPF LSM Kernel Gate	Synchronous in-kernel LSM policy enforcement (bpf_lsm_*) with dynamic Syzkaller boundary fuzzing and Tetragon export.	pytest examples/ebpf-lsm-kernel-gate/test_lsm_gate.py
AST Semantic Reconciler	3-way commutative AST symbol merger eliminating false git conflicts and unifying import sets with SARIF export.	pytest examples/ast-semantic-reconciler/test_reconciler.py
Wasm Capability Sandbox	WASI 0.2 object-capability isolation, WIT interface validation, and gas-metered execution eliminating ambient authority.	pytest examples/wasm-capability-sandbox/test_wasm_sandbox.py
AST-CRDT Collaborative Editor	Real-time AST Tree-CRDT collaborative editor with Lamport clocks, fractional ordering, and cycle-free distributed convergence.	pytest examples/ast-crdt-collaborative-editor/test_ast_crdt.py

---

🌐 Infrastructure & Observability Resources (resources/)

Production-ready infrastructure configurations, container sandboxes, and observability pipelines for agent swarms:

Category	Key Resources	Description
Observability Mesh	otel-collector-config.yaml prometheus-agent-alerts.yaml grafana/agent-telemetry-dashboard.json	OTel Collector pipeline with memory limiter and log scrubbing, Prometheus alert rules for token burn spikes and invariant failures, and turnkey Grafana dashboard.
Kubernetes Manifests	sandbox-pod.yaml network-policy.yaml resource-quota.yaml otel-collector-deployment.yaml	Hardened, unprivileged pod specs (Restricted PSS), zero-trust egress NetworkPolicy dropping RFC 1918/metadata access, namespace quotas, and in-cluster OTel/Jaeger/Valkey.
Docker Compose Stack	docker-compose.yml .env.example	Turnkey 6-service local evaluation environment (jaeger, otel-collector, prometheus, valkey, grafana, agent-sandbox) with single-command startup (docker compose up -d).

Read the full Resources Guide (resources/README.md).

---

🏆 Multi-Agent Benchmark Suite (benchmarks/)

An automated, quantitative benchmark runner evaluating AI coding agents across four operational tracks:

python3 benchmarks/benchmark_runner.py

Evaluation Track	Focus Metric	Passing Threshold
Complexity Refactoring	Cyclomatic complexity reduction on procedural code	$M \le 10$ and $\ge 50%$ complexity reduction
CEGIS Convergence	Rounds required to synthesize minimal patches under negative constraints	Converged within $\le 6$ iterative rounds
Token Economy	Frontier cloud token savings via local subagent slot offloading	$\ge 70%$ cloud token reduction
Rust Type-State Pattern	Compile-time state machine invariant enforcement and zero-cost abstractions	100% cargo test pass rate, 0 unsafe blocks, and 0 bytes memory overhead

Read the full Benchmark Suite Guide (benchmarks/README.md).

---

🗺️ Strategic Roadmap

Follow our multi-milestone evolution from foundational case studies to polyglot testbeds, multi-agent benchmark suites, and autonomous self-curating swarms:

• v0.1.0 — Foundations & Retrospective (✅ Completed): Architecture, Manifesto, Taxonomy, 6 devops-cli Case Studies, 4 Core Patterns, and FastMCP schemas.
• v0.2.0 — Interactive Testbeds & Reference Apps (✅ Completed): AST Sentinel, FastMCP Gateway, CEGIS Workbench, CI matrix, Project Tooling, and Autonomous GitHub Workflows.
• v0.3.0 — Benchmark Suites & Observability Mesh (✅ Completed): Multi-Agent Benchmark Runner, Waterfall Trace Generator, Prompt Mutation Fuzzing, Tool Contract Verification, AST Conditional Refactorer, and Valkey L2 Repomap Cache.
• v0.4.0 — Polyglot Invariants & Ephemeral Sandboxes (🔄 Active / In Flight): Go Goroutine Leak Sentinel, Rust Type-State Track, Rootless Docker Container Sandboxes, and Tree-Sitter CST engine.
• v0.5.0 — Autonomous Swarm Orchestration (📋 Planned): Closed-loop PR Triage Bot, Conversation-to-Case-Study Synthesizer, and Live Multi-Model Cost-per-Invariant Index.
• v1.0.0 — Enterprise Governance & Living Standard (💡 North Star): AIBOM Supply-Chain Scanner, Prompt Injection Egress Validator, and Certified Living Standard.

Read the complete Strategic Roadmap (docs/ROADMAP.md) including the prioritized Value vs. Effort matrix and Living Research Queue.

---

🤖 Autonomous Recursive Development Cycle & Tooling

vibes operates on a positive recursive development cycle designed for autonomous operation with zero required human manual intervention:

flowchart LR
    Issue[Issue / Goal] --> Triage["autonomous-triage.yml<br>(tools/project_tooling.py)"]
    Triage --> Ground[Auto-Label & Ground Acceptance Criteria]
    Ground --> AgentDev[Agent TDD Implementation]
    AgentDev --> PRSentinel["pr-sentinel.yml<br>(AST Invariant Gate)"]
    PRSentinel --> Merge[Merge PR]
    Merge --> Hardening["recursive-hardening.yml<br>(AGENTS.md Audit)"]
    Hardening --> Next[Self-Hardened Knowledge Base]

Loading

Tooling & Automated Workflows:

• JIT Instruction Governor & Ablation Engine (tools/instruction_governor.py): Resolves instruction ratchet bloat and lost-in-the-middle attention decay by parsing instructions into token-weighted sections, mapping mechanical gate codes to rule sections (Rule Attribution Matrix), synthesizing lean two-tier JIT prompt envelopes ($\le 2$k kernel + targeted overlays), and evaluating counterfactual ablation candidates.
• Project Tooling CLI (tools/project_tooling.py): Rate-managed client for issue classification, acceptance criteria parsing, and self-hardening audits.
• SDLC Project Manager CLI (tools/sdlc_project_manager.py): Deterministic multi-dimensional priority scoring, dependency graph cycle detection, and agent next-action dispatch.
• Resource Iteration Workbench (tools/resource_iteration_workbench.py): Continuous Scan -> Run -> Review -> Feedback -> Iterate engine computing quality scores, proactive refactoring opportunities, and automated SDLC backlog tasks.
• Automated AST Conditional Refactorer (tools/ast_refactorer.py): Mechanical AST rewriting engine auto-decomposing branching ladders ($M \ge 7$) and nesting depth into table dispatch mappings, early-return guard clauses, pure predicate helpers, and consolidated assertion tuples with round-trip safety verification.
• Documentation Syntax & Link Validator (tools/docs_validator.py): High-performance documentation validator checking nested code fences, Mermaid AST, markdown table column alignments, local anchor slugs, and embedded snippet syntax.
• CEGIS Invariant Repair Engine (tools/cegis_engine.py): Counterexample-guided inductive synthesis engine replacing conversational "try-again" loops with mathematically grounded negative constraint accumulation, monotonic convergence verification, cycle oscillation detection, and latent regression prevention.
• Context Rot Auditor & Compactor (tools/context_rot_auditor.py): Attention dilution and context rot inspector calculating the Attention Dilution Index (ADI), detecting lost-in-the-middle invariant decay, and executing active multi-scale compaction via observation masking and suffix anchor re-pinning.
• C++ RAII & Lifetime Invariant Sentinel (tools/cpp_lifetime_sentinel.py): Static analysis sentinel scanning C++ source code for memory deallocation violations (CPP001), dangling view lifetimes over temporaries (CPP002), Rule of Five incompleteness (CPP003), unmanaged raw pointers (CPP004), and use-after-move hazards (CPP005) with OASIS SARIF 2.1.0 telemetry export.
• eBPF Process Tracing & Sandbox Introspection Oracle (tools/ebpf_tracer.py): Kernel-level runtime execution auditor capturing immutable syscall event streams (Tetragon, Falco, bpftrace) to detect unauthorized binary execution (EBPF001), private network egress (EBPF002), workspace file escapes (EBPF003), privilege escalation (EBPF004), and anti-debugging evasion (EBPF005) with automated Tetragon TracingPolicy synthesis and OASIS SARIF 2.1.0 exports.
• Dynamic Multi-Model Router & Speculative Cascade Oracle (tools/model_router.py): Multi-model execution coordinator evaluating task complexity vectors and semantic entropy uncertainty to dynamically route tasks across Local (7B), Fast (32B/Haiku), and Frontier (Sonnet/GPT-4o) tiers. Features speculative cascading executing lightweight drafts against mechanical AST invariant oracles ($M \le 10, d \le 5$, zero RFC 1918) with negative constraint escalation upon failure, achieving 85.6% cost reduction and 100.8% APGR.
• Semantic Graph AST Code Memory & Symbol Indexer (tools/code_memory.py): Persistent AST symbol index and directed call graph memory maintaining def-use chains, signature stability (SGM002), circular dependency avoidance (SGM003), and transitive blast radius analysis across multi-file refactoring sessions with OASIS SARIF 2.1.0 exports and WCAG AA Mermaid visualizations.
• Application Factory (tools/app_factory.py): A contract declaring an application's operations and their argument types becomes a runnable application — dispatch table, JSON Schema with additionalProperties: false, prescriptive rejections listing every breach at once, timed invocations, CLI, contract tests and a structured README. What makes it a factory for this repository is the acceptance test: the emitted application passes the AST invariant sentinel, ruff, mypy, the documentation validator and its own generated suite with no edit, and tests/test_app_factory.py runs those real gates over the real output. handlers.py is written once and never regenerated, because a factory that owns the domain logic becomes a framework nobody can leave. A contract may declare variables and collect their values interactively, from --set, or from a recorded answers file — always with a default, so it still resolves when nobody is watching, and never prompting when stdin is not a terminal.
• Portfolio Balance (tools/portfolio_balance.py): Reports what the repository has against where its recent lines went. The drift it exists to surface is invisible from inside any single change — every tooling commit is defensible and the aggregate is not. Counts added lines rather than touched files, because a repository-wide lint sweep touches many locations and builds nothing: on the window that prompted this, touches read 52/48 and lines read 7/93. Steers, never gates.
• Finding Baseline (tools/finding_baseline.py): Records a codebase's existing findings so a gate can be turned on before the codebase passes it — the most-cited gap in the landscape survey, held by lizard, vulture, wily and promptfoo. Operates on normalized SARIF results, so one baseline covers every oracle and composes with any SARIF-emitting tool. Entries are pruned when their finding is fixed, because a suppression file that never shrinks goes on hiding a defect that was repaired and later reintroduced. This repository's own baseline is empty and a test keeps it that way.
• Instrument Fuzzer (tools/fuzz_harness.py): Turns the oracles on themselves. Generates and mutates Python modules, Markdown documents, roadmaps and manifests, then asserts four mechanically decidable properties of each instrument — that it raises nothing it has not declared, answers identically for identical input across hash seeds, converges when it repairs, and finishes. Every input that breaks one is minimized by delta debugging and kept in artifacts/fuzz-corpus/, which is replayed as a gate; the random search runs on a schedule, where a lucky run is a finding rather than a red build.
• Milestone Scope Governor & Release Air-Lock Oracle (tools/milestone_governor.py): Detects and resolves the Milestone Horizon Inflation Trap and scope cascades in autonomous AI agent workflows. Enforces a 3-phase milestone lifecycle (INTAKE → AIR_LOCKED → FROZEN), computes rolling Scope Injection Velocity ($V_{\text{scope}}$), Burn Velocity ($V_{\text{burn}}$), and the Convergence Ratio ($C_R \ge 1.2$), and partitions open backlogs into retained P0 blockers vs. vNext rollover candidates with OASIS SARIF 2.1.0 telemetry export.
• Conversation-to-Case-Study Synthesizer (tools/conversation_synthesizer.py): Automated pipeline ingesting raw agent trajectory logs (JSONL transcripts), enforcing zero-trust redaction (RFC 5737 IPs, example.com hostnames, secret masking, user path generalization), extracting quantitative telemetry and AST complexity metrics, and drafting structured 5-section observation reports with Mermaid diagrams.
• Continuous Quality Gate (.github/workflows/ci.yml): Multi-version Python test matrix and AST Invariant Sentinel validation.
• CodeQL Static Analysis (.github/workflows/codeql.yml): Automated semantic security analysis scanning for vulnerabilities and invariant breaches across Python and GitHub Actions workflows.
• Autonomous Issue Triage (.github/workflows/autonomous-triage.yml): Automatic taxonomy labeling and onboarding checklist generation.
• PR Architectural Sentinel (.github/workflows/pr-sentinel.yml): Automated diff inspection blocking complexity creep and IP leaks.
• Recursive Self-Hardening (.github/workflows/recursive-hardening.yml): Enforces the mandate that every defect fix must harden AGENTS.md.
• Scheduled Instrument Fuzzing (.github/workflows/fuzz.yml): Daily exploration and cross-hash-seed determinism check, publishing minimized inputs as artifacts rather than committing them.

---

🤝 Contributing & Submitting Artifacts

Contributing an experience from your own agent sessions? Start with the Agentic Experience Contribution Harness — five staged prompts that extract a publishable observation from a real session, or establish that the session does not contain one. Most do not, and the harness is built to say so.

We invite AI researchers, agent engineers, and developers to contribute notable observations, prompt harnesses, benchmark findings, and case studies:

• Read the Curation Guidelines to understand artifact formatting, secret redaction, and verification criteria.
• Use our Issue Templates to submit an Observation Report or Artifact Submission.
• AI Agents contributing directly must follow the canonical instructions in AGENTS.md.

---

📄 License

This repository is distributed under the terms of the Apache License, Version 2.0.

---

🧭 Directory Map

├── .github/
│   ├── ISSUE_TEMPLATE/                # Issue templates for observations and artifacts
│   ├── PULL_REQUEST_TEMPLATE.md       # Pull request template with sanitization rubric
│   ├── labels.yml                     # Labels the roadmap jobs read and apply
│   ├── project-template.json          # Declarative GitHub Projects v2 schema template
│   ├── roadmap.toml                   # Roadmap configuration and project board mapping
│   └── workflows/                     # Autonomous recursive CI/CD workflows
│       ├── ci.yml                     # Multi-version test & AST invariant certification
│       ├── codeql.yml                 # CodeQL semantic security & invariant analysis
│       ├── autonomous-triage.yml      # Autonomous taxonomy labeling & onboarding
│       ├── fuzz.yml                   # Daily instrument fuzzing & hash-seed determinism check
│       ├── pr-sentinel.yml            # Automated PR diff invariant gate & certification
│       └── recursive-hardening.yml    # Closed-loop AGENTS.md hardening audit
│
├── AGENTS.md                          # Foundational agent operating instructions for vibes
├── CHANGELOG.md                       # Structured release history
├── CONTRIBUTING.md                    # Contributor entry point, local gates, and conventions
├── LICENSE                            # Apache 2.0 open-source license
├── README.md                          # Repository homepage and exhibition tour (this file)
├── pyproject.toml                     # Project metadata and the single dependency manifest
├── pytest.ini                         # Isolated test config preventing parent plugin discovery
│
├── docs/                              # Foundational theory, taxonomy, and curation standards
│   ├── MANIFESTO.md                   # Beyond "Vibe Coding": The Disciplined Agentic Manifesto
│   ├── TAXONOMY.md                    # Structured taxonomy of agentic architectures & failure modes
│   ├── RETROSPECTIVE.md               # Empirical retrospective on autonomous dynamics & mechanical oracles
│   ├── CURATION_GUIDELINES.md         # Guidelines for submitting & sanitizing artifacts
│   ├── EMPIRICAL_FOUNDATIONS.md       # Critical synthesis cross-examining assertions against external literature
│   ├── agent/                         # Autonomous agent task tracking and project boards
│   ├── archive/                       # Delivered roadmap scope, retained for provenance
│   ├── dummysguide/                   # Beginner-friendly fundamentals without technical mumbo jumbo
│   ├── landscape/                     # Comparable-project survey: manifest, facts snapshot, report
│   ├── reliability/                   # Committed error budget ledger (one shard per iteration)
│   └── ROADMAP.md                     # Strategic high-density product roadmap & milestones
│
├── observations/                      # Empirical field studies & engineering breakthroughs
│   ├── README.md                      # Consolidated field observations & architectural synthesis
│   ├── devops-cli/                    # In-depth case studies from the devops-cli project
│   │   ├── 01-tdd-as-living-contract.md
│   │   ├── 02-architectural-invariants-and-complexity-caps.md
│   │   ├── 03-autonomous-project-governance.md
│   │   ├── 04-zero-trust-egress-and-sanitization.md
│   │   ├── 05-harness-slots-and-subagent-offloading.md
│   │   ├── 06-rate-limits-and-anti-brittle-heuristics.md
│   │   ├── 07-proactive-headroom-and-recursive-feedback-loops.md
│   │   ├── 08-closed-loop-feedback-inversion-and-autonomous-quality-elevation.md
│   │   ├── 09-mechanical-ast-rewriting-and-automated-refactoring-convergence.md
│   │   ├── 10-negative-tool-contract-assertions-and-prescriptive-prompt-synthesis.md
│   │   ├── 11-assertion-density-and-structural-tuple-consolidation.md
│   │   ├── 12-polyglot-cst-boundary-guards-and-symlink-containment.md
│   │   ├── 13-streaming-reasoning-token-parsers-and-think-block-sanitization.md
│   │   ├── 14-binary-search-ast-context-packing-and-token-budgeting.md
│   │   ├── 15-llm-structured-output-repair-and-schema-reconciliation.md
│   │   ├── 16-ci-staleness-and-milestone-freeze-anti-pattern.md
│   │   ├── 17-semantic-validators-vs-structural-position-oracles.md
│   │   ├── 18-tool-cardinality-saturation-and-schema-context-taxation.md
│   │   ├── 19-context-accumulation-drift-and-lossy-reflection-truncation.md
│   │   ├── 20-model-failover-capability-cliffs-and-one-way-degradation-ratchets.md
│   │   ├── 21-milestone-horizon-expansion-and-autonomous-scope-cascades.md
│   │   └── 22-the-verification-horizon-and-validation-latency-cliffs.md
│   ├── polyglot/                      # Cross-language agentic engineering observations
│   │   ├── 01-rust-type-state-invariants.md
│   │   ├── 02-typescript-cst-and-type-gymnastics.md
│   │   ├── 03-go-goroutine-leakage-and-context-lifecycles.md
│   │   ├── 04-cpp-raii-and-lifetime-invariants-under-llm-synthesis.md
│   │   └── 05-differential-ast-mutation-fuzzing-for-polyglot-boundary-parsers.md
│   └── systems/                       # Distributed systems & observability field studies
│       ├── 01-distributed-telemetry-and-agent-waterfalls.md
│       ├── 02-subprocess-test-harness-instrumentation-tax.md
│       ├── 03-event-driven-file-watchers-and-continuous-invariant-loops.md
│       ├── 04-content-addressed-two-tier-caching-and-embedding-drift-audits.md
│       ├── 05-rootless-container-sandboxing-and-process-group-containment.md
│       ├── 06-multi-agent-concurrency-shared-workspace-hazards-and-swarm-coordination.md
│       ├── 07-agentic-ide-protocols-and-lsp-mcp-convergence.md
│       ├── 08-convention-to-mechanical-enforcement-inversion.md
│       ├── 09-multi-agent-epistemic-loss-and-delegation-boundary-distortion.md
│       ├── 10-mcp-protocol-boundaries-and-stateless-transport-constraints.md
│       ├── 11-silent-certification-failure-and-gate-integrity.md
│       ├── 12-gates-catch-their-author-first.md
│       ├── 13-verify-the-finding-before-you-fix-it.md
│       ├── 14-defect-shaped-loops-and-the-feature-blind-spot.md
│       ├── 15-a-count-is-not-a-cost.md
│       ├── 16-the-prioritizer-is-not-under-test.md
│       ├── 17-a-fuzzers-first-report-is-about-the-fuzzer.md
│       ├── 18-a-correction-inherits-the-frame-it-corrects.md
│       ├── 19-self-consistency-is-not-conformance.md
│       ├── 20-internet-grounded-information-foraging-and-self-improvement-loops.md
│       ├── 21-hierarchical-subagent-slot-offloading-and-epistemic-loss.md
│       ├── 22-self-correction-loops-vs-cegis-constraint-accumulation.md
│       ├── 23-attention-dilution-context-rot-and-active-compaction.md
│       ├── 24-ebpf-process-tracing-for-agent-sandbox-introspection.md
│       ├── 25-multi-model-capability-boundaries-and-dynamic-routing-oracles.md
│       ├── 26-semantic-graph-ast-code-memory-and-persistent-symbol-indexing.md
│       ├── 27-agentic-project-self-documentation-and-the-phantom-architecture-trap.md
│       ├── 28-recursive-self-improvement-and-the-post-harness-mandate.md
│       ├── 29-epistemic-drift-and-the-unreliable-teacher-in-autonomous-verification.md
│       ├── 30-kinetic-falsification-and-the-ephemeral-exploit-harness.md
│       ├── 31-instruction-ratchet-bloat-and-counterfactual-agent-ablation.md
│       ├── 32-dual-first-class-consumers-and-bi-directional-agentic-feedback-loops.md
│       ├── 33-typed-epistemic-seams-and-lossless-subagent-handshakes.md
│       ├── 34-ebpf-lsm-kernel-gates-and-dynamic-containment-fuzzing.md
│       ├── 35-3-way-ast-semantic-reconciliation-and-worktree-collision-arbitration.md
│       ├── 36-wasi-component-models-and-capability-based-tool-sandboxing.md
│       ├── 37-real-time-ast-crdts-and-concurrent-multi-agent-swarms.md
│       ├── 38-graph-ranked-ast-context-optimization-and-personalized-pagerank.md
│       ├── 39-test-harness-integration-and-zero-overhead-goroutine-leak-sentinels.md
│       ├── 40-configurable-prose-style-guides-and-inclusive-terminology-gates.md
│       ├── 41-radon-block-complexity-ranking-in-code-smell-quantification.md
│       ├── 42-language-server-protocol-and-automated-ast-invariant-repair.md
│       ├── 43-contract-driven-template-ecosystems-and-in-place-updates.md
│       ├── 44-polyglot-token-normalization-and-multi-language-code-smell-quantification.md
│       ├── 45-sycophantic-compliance-and-mechanical-refusal-oracles.md
│       ├── 46-closed-loop-pr-review-thread-synchronization-and-atomic-resolution.md
│       ├── 47-biological-autopoiesis-homeostatic-damping-and-afferent-observability.md
│       ├── 48-the-improv-axiom-and-generative-headroom-elevation.md
│       └── 49-dissipative-structures-and-allometric-metabolism-in-agentic-swarms.md
│
├── patterns/                          # Operational playbooks for human-agent collaboration
│   ├── 3-way-ast-semantic-reconciliation.md
│   ├── adaptive-headless-web-crawling.md
│   ├── agentic-ide-lifecycle-hooks-and-lsp-oracles.md
│   ├── ast-crdts-for-real-time-agent-collaboration.md
│   ├── ast-graph-relevance-ranking-and-context-packing.md
│   ├── autonomous-sdlc-project-management.md
│   ├── bi-directional-metric-feedback-and-ax-scoring.md
│   ├── binary-search-context-packing.md
│   ├── capability-based-wasm-sandboxing.md
│   ├── cegis-and-hypothesis-debugging.md
│   ├── closed-loop-pr-review-thread-synchronization.md
│   ├── collision-free-worktree-fleet-allocation.md
│   ├── configurable-prose-style-and-terminology-gates.md
│   ├── contract-template-ecosystem-and-in-place-updates.md
│   ├── deterministic-oracles-and-feedback-inversion.md
│   ├── dissipative-entropy-reduction-and-allometric-swarm-routing.md
│   ├── epistemic-hygiene-and-context-pruning.md
│   ├── epistemic-seam-and-mitigated-defect-auditing.md
│   ├── error-budget-driven-feedback-inversion.md
│   ├── fifo-pull-request-shepherding.md
│   ├── findings-must-carry-their-own-falsification.md
│   ├── gate-integrity-and-total-input-coverage.md
│   ├── invariant-grounded-recursive-self-improvement.md
│   ├── iterative-resource-refinement-loop.md
│   ├── just-in-time-instruction-decomposition-and-ablation.md
│   ├── kernel-enforced-lsm-sandbox-containment.md
│   ├── kinetic-exploit-probes-and-invariant-leashing.md
│   ├── lsp-diagnostics-and-automated-invariant-repair.md
│   ├── milestone-airlock-and-scope-freeze-governance.md
│   ├── multi-agent-codebase-concurrency.md
│   ├── multi-tier-living-documentation.md
│   ├── polyglot-token-normalization-and-clone-quantification.md
│   ├── post-v1-deprecation-lifecycle.md
│   ├── radon-block-complexity-ranking-and-smell-quantification.md
│   ├── root-cause-hardening.md
│   ├── streaming-reasoning-isolation-and-token-budgeting.md
│   ├── structural-position-oracles.md
│   ├── structure-driven-ci-directory-contracts.md
│   ├── sycophantic-compliance-and-mechanical-refusal.md
│   ├── synthetic-chaos-and-invariant-convergence-testing.md
│   ├── test-harness-concurrency-leak-sentinel.md
│   ├── the-harold-multi-agent-swarm-orchestration.md
│   ├── the-improv-axiom-and-generative-headroom-elevation.md
│   ├── tiered-verification-pyramid-and-sub-second-oracles.md
│   ├── tool-cardinality-budget-management.md
│   └── zero-trust-sandboxing-and-observability.md
│
├── artifacts/                         # Battle-tested prompts, harnesses, and schemas
│   ├── prompts/
│   │   ├── multi-persona-code-reviewer.md
│   │   ├── architectural-invariant-sentinel.md
│   │   └── experience-contribution-harness.md
│   ├── task-harnesses/
│   │   ├── structured-task-spec-template.md
│   │   └── sample-completed-task-spec.md
│   ├── contracts/                     # Application contracts the factory builds from
│   ├── finding-baseline.json          # Findings this repository accepts; empty, and tested so
│   ├── fuzz-corpus/                   # Inputs that broke an instrument; replayed as a gate
│   └── schemas/
│       ├── fastmcp-agent-tool-manifest-spec.json
│       └── sarif-schema-2.1.0.json     # OASIS SARIF 2.1.0 schema: the code scanning oracle
│
├── resources/                         # Infrastructure & Observability configurations
│   ├── observability/                 # OTel Collector, Prometheus alerts, Grafana dashboard
│   ├── k8s/                           # Hardened sandbox pod, NetworkPolicy, OTel manifests
│   └── docker-compose/                # Turnkey 6-service local evaluation environment
│
├── examples/                          # Executable reference sample applications
│   ├── adaptive-web-crawler/          # Two-tier adaptive crawler with domain strategy memory
│   ├── agent-experience-evaluator/    # Agent Experience (AX) evaluator & cognitive impedance auditor
│   ├── agent-telemetry-trace-generator/ # OpenTelemetry waterfall trace generator
│   ├── agentic-ide-hook-sentinel/     # Zero-trust IDE lifecycle hook & process group guard
│   ├── ast-crdt-collaborative-editor/ # Real-time AST Tree-CRDT collaborative editor & swarm convergence
│   ├── ast-invariant-sentinel/        # AST complexity <= 10 & IP leak analyzer
│   ├── ast-relevance-context-ranker/  # Personalized PageRank AST context optimizer & relevance packer
│   ├── ast-semantic-reconciler/        # Autonomous 3-way AST semantic reconciler & conflict arbitrator
│   ├── binary-search-context-packer/  # Binary search AST prompt context packer
│   ├── cegis-debugging-workbench/     # Counterexample synthesis testbench
│   ├── chaos-invariant-monkey/        # Chaos engineering & agent self-healing benchmark
│   ├── code-smell-quantifier/         # Deterministic smell measurement (MI, clones, LCOM4)
│   ├── deprecation-lifecycle-sentinel/ # Post-1.0 deprecation contract & removal deadline gate
│   ├── ebpf-lsm-kernel-gate/          # Synchronous in-kernel LSM gate & Syzkaller boundary fuzzer
│   ├── ephemeral-container-sandbox/   # Hardened rootless container sandbox & CIS benchmark auditor
│   ├── epistemic-context-handshake/   # Typed context envelope protocol & loss auditor
│   ├── fastmcp-token-bucket-gateway/  # Paced tool gateway with jittered backoff
│   ├── go-leak-sentinel/              # Go concurrency runtime trace analyzer & leak sentinel
│   ├── polyglot-cst-parser/           # Multi-language CST/AST engine with boundary containment guards
│   ├── polyglot-mutation-fuzzer/      # Differential AST mutator & boundary fuzzer
│   ├── prompt-mutation-fuzzer/        # Grammar-guided prompt perturbation & invariant drift testbed
│   ├── streaming-reasoning-sanitizer/ # Streaming reasoning FSM parser & bounded stream sanitizer
│   ├── tool-contract-verifier/        # Formal JSON Schema contract verification & negative assertion gate
│   ├── valkey-l2-repomap-cache/       # High-throughput Valkey L2 AST cache & embedding drift auditor
│   ├── wasm-capability-sandbox/       # WASI 0.2 object-capability sandbox & gas-metered execution
│   └── worktree-swarm-arbiter/        # Git worktree fleet broker & lease manager
│
├── benchmarks/                        # Multi-agent benchmark suite
│   ├── README.md                      # Benchmark suite overview and scoring methodology
│   ├── benchmark_runner.py            # Standardized runner (Complexity, CEGIS, Token Economy)
│   └── test_benchmark_runner.py       # Automated benchmark certification tests
│
├── tools/                             # Autonomous project management tooling
│   ├── verification_pyramid_auditor.py # Verification pyramid auditor, latency scaling & assertion sprawl oracle
│   ├── instruction_governor.py        # JIT instruction governor, rule attribution & counterfactual ablation
│   ├── kinetic_probe.py               # Kinetic counterexample probe engine & invariant leash registry
│   ├── code_memory.py                 # Semantic graph AST code memory, symbol indexer & blast radius oracle
│   ├── model_router.py                # Dynamic multi-model router & speculative cascade oracle with SARIF export
│   ├── ebpf_tracer.py                 # eBPF process tracing & sandbox introspection oracle with SARIF export
│   ├── cpp_lifetime_sentinel.py       # C++ RAII & lifetime invariant sentinel with SARIF export
│   ├── context_rot_auditor.py         # Attention dilution & context rot auditor with active compactor
│   ├── cegis_engine.py                # Counterexample-guided inductive synthesis & invariant repair oracle
│   ├── aibom_scanner.py               # AI Bill of Materials (AIBOM) & supply-chain security scanner
│   ├── prompt_injection_scanner.py    # Adversarial prompt injection & CWE-200 egress security scanner
│   ├── deprecation_protocol.py        # Enterprise change management & version deprecation protocol
│   ├── living_standard_certifier.py   # Certified living standard for agentic engineering
│   ├── project_tooling.py             # CLI for issue triage and self-hardening audits
│   ├── pr_triage_bot.py               # Closed-Loop PR Triage & Invariant Review Bot
│   ├── pr_thread_sync.py              # Closed-Loop PR Review Thread Synchronizer & Atomic Resolver
│   ├── conversation_synthesizer.py    # Autonomous conversation-to-case-study synthesizer
│   ├── model_leaderboard.py           # Multi-model benchmark leaderboard & cost-per-invariant index
│   ├── subagent_orchestrator.py       # Hierarchical subagent slot offloading orchestrator
│   ├── sdlc_project_manager.py        # SDLC resource prioritization & Kanban engine
│   ├── resource_iteration_workbench.py # Automated Scan-Run-Review-Iterate workbench
│   ├── ast_refactorer.py              # Automated AST conditional refactorer
│   ├── milestone_governor.py          # Milestone scope governor, convergence ratio & release air-lock oracle
│   ├── doc_core.py                    # Shared finding types and fenced-block extraction
│   ├── doc_rules_mermaid.py           # Mermaid label, diagram type, and WCAG contrast rules
│   ├── doc_rules_polyglot.py          # Multi-format doc parsing and polyglot snippet validation
│   ├── doc_rules_structure.py         # Observation structure and directory map oracles
│   ├── doc_rules_style.py             # Prose style, terminology, and inclusive language rules
│   ├── docs_validator.py              # Documentation syntax, code fence, Mermaid, and link validator
│   ├── reliability_slo.py             # SLO objectives, error budgets, and loop phase policy
│   ├── roadmap_ingest.py              # Parses roadmap deliverables into the SDLC backlog
│   ├── app_factory.py                 # Contract in, gate-clean runnable application out
│   ├── contract_variables.py          # Shared: contract questions, answers and safe rendering
│   ├── landscape_survey.py            # Maturity, feature comparison and gap-to-roadmap survey
│   ├── portfolio_balance.py           # What the repository builds against what it judges
│   ├── roadmap_emit.py                # Shared: machine findings to idempotent roadmap proposals
│   ├── finding_baseline.py            # Accepts existing findings so a gate can be adopted
│   ├── fuzz_core.py                   # Shared: corpus generation, mutation and delta shrinking
│   ├── fuzz_harness.py                # Fuzzes the instruments themselves; replays what broke them
│   ├── metric_reference.py            # One row per metric: who computes it, and why not us
│   ├── sarif_report.py                # Every oracle's findings as one schema-valid SARIF log
│   ├── semconv_snapshot.py            # Derives the GenAI semantic conventions from upstream
│   ├── seccomp_synthesizer.py         # Automated Seccomp BPF profile synthesizer for agent tools
│   ├── supply_chain_audit.py          # Dependency, action, package and egress audit with fixes
│   ├── sanitization_policy.py         # Single definition of addresses code and docs may name
│   ├── upstream_facts.py              # Shared: GitHub repository facts and maturity scoring
│   ├── source_tree_policy.py          # Single definition of which paths are repository source
│   └── verify_mermaid.mjs             # Mermaid render gate using the real engine under jsdom
│
└── tests/                             # Automated test suites for tools and harnesses
    ├── test_empirical_foundations.py  # Unit tests for empirical foundations & critical synthesis
    ├── test_verification_pyramid_auditor.py # Unit tests for verification pyramid auditor & assertion density
    ├── test_instruction_governor.py   # Unit tests for JIT instruction governor & ablation engine
    ├── test_milestone_governor.py     # Unit tests for milestone scope governor and air-lock oracle
    ├── test_kinetic_probe.py          # Unit tests for kinetic probe execution & invariant leashes
    ├── test_code_memory.py            # Unit tests for code memory, call graph invariants & SARIF
    ├── test_model_router.py           # Unit tests for multi-model router, speculative cascade & SARIF
    ├── test_ebpf_tracer.py            # Unit tests for eBPF tracer, Tetragon/Falco policy & SARIF
    ├── test_cpp_lifetime_sentinel.py  # Unit tests for C++ lifetime sentinel, Rule of Five & SARIF
    ├── test_context_rot_auditor.py    # Unit tests for context rot auditor, ADI scoring & compactor
    ├── test_cegis_engine.py           # Unit tests for CEGIS engine, negative constraints & convergence
    ├── test_aibom_scanner.py          # Unit tests for AIBOM and model supply-chain security scanner
    ├── test_prompt_injection_scanner.py # Unit tests for prompt injection and CWE-200 egress scanner
    ├── test_deprecation_protocol.py   # Unit tests for deprecation protocol & tool schema migrator
    ├── test_living_standard_certifier.py # Unit tests for living standard certifier & attestation
    ├── test_app_factory.py            # Runs the real gates over the factory's own output
    ├── test_contract_variables.py     # Contract questions, answer coercion and safe rendering
    ├── test_semconv_snapshot.py       # Deriving the GenAI convention table from upstream
    ├── test_seccomp_synthesizer.py    # Unit tests for Seccomp BPF profile synthesis and OCI output
    ├── test_address_policy_agreement.py # Five copies of one address policy, compared
    ├── test_metric_reference.py       # Who computes each metric, and the witnesses why
    ├── test_portfolio_balance.py      # Unit tests for portfolio and investment ratios
    ├── test_project_tooling.py        # Unit tests for autonomous project engine
    ├── test_pr_triage_bot.py          # Unit tests for multi-persona PR triage and review bot
    ├── test_pr_thread_sync.py         # Unit tests for closed-loop PR review thread synchronizer
    ├── test_conversation_synthesizer.py # Unit tests for conversation synthesizer & telemetry
    ├── test_model_leaderboard.py      # Unit tests for multi-model leaderboard and cost-per-invariant index
    ├── test_subagent_orchestrator.py  # Unit tests for hierarchical subagent slot offloading orchestrator
    ├── test_resources_validation.py   # Unit tests verifying K8s, Docker, and OTel resources
    ├── test_sdlc_project_manager.py   # Unit tests for SDLC project manager & scoring engine
    ├── test_resource_iteration_workbench.py # Unit tests for iteration workbench engine
    ├── test_ast_refactorer.py         # Unit tests for AST conditional refactoring engine
    ├── test_reliability_slo.py        # Unit tests for SLO error budgets and phase policy
    ├── test_roadmap_ingest.py         # Unit tests for roadmap deliverable ingestion
    ├── test_sdlc_sync.py              # Unit tests for backlog reconciliation and promotion
    ├── test_landscape_survey.py       # Unit tests for maturity scoring and gap-to-roadmap emission
    ├── test_finding_baseline.py       # Unit tests for baseline acceptance, staleness and pruning
    ├── test_fuzz_core.py              # Unit tests for input generation, mutation and shrinking
    ├── test_fuzz_harness.py           # Asserts every fuzzing property fires on a broken instrument
    ├── test_sarif_report.py           # Unit tests for SARIF emission and schema conformance
    ├── test_source_tree_policy.py     # Unit tests pinning one corpus definition across instruments
    ├── test_supply_chain_audit.py     # Unit tests for dependency inventory, risk and mechanical fixes
    ├── test_upstream_facts.py         # Unit tests for repository facts and maturity scoring
    ├── test_docs_validator.py         # Unit tests for documentation syntax and link validation
    ├── test_workflow_contracts.py     # Resolves every workflow's commands against the real CLIs
    └── test_gate_manifest.py          # Asserts every documented quality gate is wired into CI