L0 — Adversarial Validation Engine

Status: complete, within an honestly stated scope. 15 tests (8 scenario, 7 property). 250 total across the repo.

What L0 is here, and what it can't be

L0 sits outside the L1–L9 stack rather than inside it: every other layer defends the run; this one checks whether the layers actually hold — and whether they hold together, not just individually. The original design described it as the layer that turns every "not verified here" note across these docs into something checked on real hardware.

That can't be built in this environment. This sandbox has no /dev/kvm and no kernel privileges, so containment.backend.FirecrackerBackend is still exactly what its own docstring says: "reviewed but not exercised... until the L0 adversarial validation engine runs it on real hardware." That sentence is still true after this module. Whether Firecracker actually isolates, whether the fanotify/eBPF collector L7 assumes delivers what MutationObservation expects, whether vsock actually enforces one-direction-only data flow — none of that is checked here, and nothing below claims otherwise.

What is honestly buildable, and is what got built:

1. Full-stack composed scenarios (`validation/scenarios.py`)

Every adversarial test suite in this repo, up to this point, tests one layer with the layers below it faked or hand-constructed. L9's own tests build Evidence by typing containment_failed=True directly; L1's tests never drive a real Broker. That's the correct way to unit-test a layer in isolation, and it leaves exactly one thing unchecked: does the composition actually work when real components are wired together, not a hand-typed stand-in for what one "should" produce.

ScriptedBackend is the piece that makes this possible without touching Supervisor.run()'s lifecycle. A guest, in reality, acts while the VM is running — between L1's PROCESS_SPAWN(VM_ACTOR_ID) and its PROCESS_EXIT(VM_ACTOR_ID). Since Supervisor.run() is one synchronous call, the only place caller code still runs inside it is backend.wait(). ScriptedBackend.wait() runs a caller-supplied script there, so anything it does through supervisor.record_guest_claim() or the new supervisor.emit_host_event() seam lands at exactly the sequence position a real interleaved action would have.

Six scenarios, each driving real components end to end:

Scenario	Composes	Proves
`clean_baseline_run`	everything	true-negative baseline — nothing fires on nothing
`read_only_breach_triggers_absolute_kill`	real L7 `EnvironmentMonitor` → real `Evidence` → real `KillSwitch`	L7's `containment_failed` and L9's absolute rule agree
`patient_enumeration_defeats_burst_not_ewma`	real `Broker`/`DenialTracker` → real `KillSwitch`	the EWMA path fires from real denial pacing, not a hand-built signal
`well_formed_multi_actor_run_passes_gate1`	real guest spawn/act/exit + real host-attributed broker decision, interleaved	a legitimate multi-actor run doesn't false-positive
`unattributed_guest_action_after_run_end_is_fatal`	real Gate 1 over a real malformed ledger → real `KillSwitch`	persistence-after-exit is fatal through the real path, not a literal `fatal_gate1_codes` tuple
`concealed_capability_narrative_flags_drift_but_never_kills`	real `DriftMonitor` alongside real `KillSwitch`	L6 is structurally incapable of killing, not just documented as advisory

That last one is the one worth dwelling on. Every L6 doc asserts, in prose, that drift findings can't kill. This scenario doesn't trust the prose: it manufactures a real OUTCOME_MISMATCH (a guest narrating a grant for a capability the broker actually denied — the concealment shape multi-agent-mcl models) and checks the kill verdict is bit-for-bit identical to the clean baseline despite it. Evidence.from_run has no parameter that consumes a DriftFinding — there is no path to check, which is a stronger claim than "the current code doesn't happen to use it."

Two bugs this caught in itself before a single test was written

Running the scenarios directly (before writing any assertions) surfaced two real mistakes, both worth recording rather than quietly fixing:

Ledger.all_events() only yields sealed blocks. A guest claim recorded after Supervisor.run() returns sits in _pending — invisible to Gate 1 until something seals a new block over it. The unattributed_guest_action_after_run_end_is_fatal scenario originally showed a clean Gate 1 result, which was wrong; the fix is an explicit second seal_block() call, and the fact that it's needed at all is itself a small, honest finding about what "the run is over" actually means for an operator inspecting the ledger immediately after run() returns.
record_guest_claim enforces Gate 1's lineage rule exactly like a real guest action would: an actor must be spawned before anything else can be attributed to it. The concealed_capability_narrative scenario's first draft skipped the spawn and got an unintended UNATTRIBUTED_ACTION kill instead of the intended drift-only finding — caught by running the scenario, not by trusting the docstring describing what it should do.

A gap this surfaced, left open rather than papered over

record_guest_claim always attributes a spawn with parent=NO_PARENT — there is currently no way to record a guest process as a structural child of VM_ACTOR_ID, only as a root actor. Gate 1 still accepts this (a root-level spawn/exit pair is legal on its own), but it means the lineage graph doesn't actually connect "the VM" to "the guest process inside it" the way the framework's narrative implies. Fixing it means adding a parent parameter to Supervisor.record_guest_claim — real API surface, and a decision for whoever owns L1's supervisor next, not something this scenario module should quietly work around.

2. Property-based fuzzing (`validation/properties.py`, `tests/test_l0_properties.py`)

Every example-based test in this repo answers "does the code handle this attack a human thought of" — necessary, and also exactly the kind of test an adversary who has read the test file can plan around. A hand-picked example set is finite and knowable. Property-based testing (via Hypothesis) asks a different question — does an invariant hold for every input in a class, including ones nobody picked — across machine-generated cases on every run.

Seven properties, each checked against 100–300 generated cases per run:

Canonical encode/decode round-trips for any structurally valid Event, not just the pinned conformance vectors.
Merkle inclusion proofs verify for every index, for randomly generated leaf lists from size 0 to 40.
The empty tree is always ZERO_DIGEST.
Flipping one byte of one leaf always changes the root (a cheap avalanche/no-collision spot check, not a claim about BLAKE3's cryptographic properties).
Gate 1 accepts any randomly generated, internally consistent process lineage tree — not just the hand-built ones in test_tamper.py.
Removing any one actor's spawn from any randomly generated tree always leaves Gate 1 unsatisfied — a fuzzed version of gate1.py's own claim that "hiding an action requires hiding a consistent set of events."
Duplicating any one actor's spawn always trips DOUBLE_SPAWN specifically.

The bug fuzzing caught immediately

The duplicated-spawn property failed on its first run. The test appended the duplicate at the end of the stream, which — depending on the randomly generated topology — could land after that actor had already exited, and Gate 1 correctly reported RESPAWN_AFTER_EXIT instead of DOUBLE_SPAWN: a different, equally correct rejection, but not the one the test claimed to check. Hypothesis's shrinking found the minimal case in seconds. The fix was to insert the duplicate immediately after the original spawn, while the actor is provably still live, which pins down DOUBLE_SPAWN regardless of topology. This is precisely the class of bug example-based testing structurally cannot find — a hand-picked example doesn't accidentally land on the wrong side of an exit boundary — and it's the strongest evidence in this repo that fuzzing and example-based testing are complementary rather than redundant.

Not guaranteed

Anything about real hardware. Firecracker's actual isolation, the fanotify/eBPF collector, vsock's actual one-directionality — none of it. This module validates composition and logical invariants in software.
Exhaustiveness of the lineage generator. lineage_stream produces a random forest with actors created in valid order and exited in reverse — not every legal interleaving Gate 1 would accept. The properties checked don't require covering every legal interleaving, only that generated streams are genuinely legal ones.
That six scenarios exhaust the composition space. They're the six that correspond to a specific claim made elsewhere in these docs (L7↔L9, L2↔L9, a legitimate multi-actor run, persistence-after-exit, L6's advisory boundary, and a clean baseline). More compositions are possible; these are the ones this pass checked.

What's left

Resolved since this doc was written: the L3/L4 question is answered in docs/l3_l4_audit.md — about half subsumed by L1/L8, half not, with the un-subsumed half (per-binary verification, spawn-token authorization) now implemented host-side in containment/identity.py.

What remains is only the hardware-dependent work named above: exercising FirecrackerBackend on a host with /dev/kvm, validating the fanotify/eBPF collector, and confirming vsock's one-directionality.