# The Runtime — one entrypoint for L1–L9 **Status:** complete. 20 tests. 292 total across the repo. --- ## Why this exists Before this module, `ames` was nine individually correct layers with no way to invoke them together. Every doc in `docs/` deferred the composition question with some version of *"wiring this is a deployment decision."* That's honest about scope — and it also means every operator would have to rediscover the correct wiring themselves. **A framework whose safe use depends on each user re-deriving the integration is a framework that will be integrated wrongly.** L0's `validation/scenarios.py` proved the layers *can* compose. This is the composition itself, as a supported API rather than a test fixture. ## Using it ```python from containment.runtime import Runtime, RuntimeConfig from containment.backend import FakeBackend report = Runtime(config).execute(spec, FakeBackend()) print(report.summary()) # run demo-01: ALLOWED report.allowed # bool report.verify() # re-checks the ledger against its checkpoint ``` `examples/run_contained_agent.py` is a runnable end-to-end demo — clean run, containment breach, and a concealed narrative — using `FakeBackend`, so it runs anywhere with no KVM and no root. ## The order is not arbitrary ``` L1 validate spec refuse an unsafe VM before anything is created L1 run boot, supervise, tear down; emit host-observed events L2 broker capability decisions, into the SAME ledger L3/L4 authorizer binary allowlist + spawn tokens, host-side L7 monitor filesystem mutations against the sealed baseline L8 gate1 structural verification of the resulting stream L9 evidence + kill host-observed evidence only, absolute rules first L5/L6 advisory computed AFTER the verdict, never inputs to it ``` The broker emits into the *same* ledger the supervisor produces, so capability decisions are sequence-ordered against VM lifecycle events rather than living in a second, uncorrelated log that a reviewer would have to align by hand. ### The advisory boundary is structural L5 and L6 are computed *after* `KillVerdict` is decided, and their outputs are not inputs to it. This isn't a convention the code politely follows: `Evidence.from_run` has **no parameter** that accepts a `SequenceVerdict` or a `DriftFinding`. There is no wiring to remove because there is no parameter to wire. Two tests pin this from different angles — one behavioural (`test_advisory_findings_never_change_the_verdict`, which drives a real concealment and asserts the verdict matches a clean run bit for bit) and one structural (`test_evidence_has_no_parameter_for_advisory_signals`, which inspects the signature, so a future refactor that adds such a parameter has to consciously break a test to do it). Why it matters: a signal built from the guest's own testimony must not be able to stop a run, or a compromised guest gains a denial-of-service primitive against the operator by simply lying. ## Fail closed, everywhere If any component raises — including one this module doesn't anticipate — `execute()` returns a report whose verdict is **KILLED**, never one that omits the failure and looks clean. An exception in the containment system must never read as "nothing to report." One deliberate exception: a spec refused by `IsolationPolicy.validate` returns **FAILED**, not KILLED. Nothing was created, so there's nothing to contain — but it is still never `allowed`, and a test asserts the backend was never touched. ## No off switches `RuntimeConfig` has no `enable_*` / `disable_*` flag for any layer, and `test_config_exposes_no_disable_switches` asserts it. An operator tunes thresholds and supplies policies; there is no supported way to switch a layer off — the same reasoning `KillSwitch` has no `disable()`. Omitting a baseline or fingerprint means that layer has nothing to compare against and reports nothing. That is **different from being disabled**: it still runs, and it still cannot be told to approve something. Every supplied policy must be **sealed** before the run — `RuntimeConfig` rejects an unsealed `BinaryPolicy`, `EnvironmentBaseline`, or `BehaviorFingerprint` at construction. An allowlist that can grow mid-run is not an allowlist. ## State never crosses a run boundary Each `execute()` builds its own supervisor, broker, monitor and authorizer. Sharing any of them across runs would carry state over a boundary — the exact thing L1 destroys the VM to prevent. ## A bug this module's own tests caught The first revision constructed the `Supervisor` with the original backend and *then* reassigned a local `backend` variable to the hook wrapper. The supervisor had already captured the unwrapped one, so `during_run` silently never fired. Four tests failed at once, which is what surfaced it — the hook must be wrapped **before** the supervisor is built, and the context it receives late-bound afterwards, because the context isn't complete until the supervisor and broker exist. Worth recording because it's the failure mode this whole module exists to prevent: a plausible-looking integration where a control is wired in but never actually runs. --- ## Not guaranteed - **Continuous evaluation.** The kill decision happens *after* the run completes, because `Supervisor.run()` is a single synchronous call and the only in-flight hook is `backend.wait()`. A backend supporting periodic callbacks could evaluate mid-run; neither backend shipped here does. **"The kill fires after the run is already finished" is a real operational limit**, not a detail — for a long-running agent, a breach at minute 2 is not acted on until the run ends. - **Enforcement of the verdict.** `Runtime` decides; L1's `destroy()` is what actually tears the VM down (and always runs, on every path). A `KILLED` report that a caller ignores is a log line. - **Anything about real hardware.** Swapping in `FirecrackerBackend` is one line, and that line is not exercised by any test here. See `docs/l0_validation.md`. ## Next The remaining work is all hardware-dependent, and the Runtime is what makes it approachable: a single `execute()` call is now the thing to point at a real KVM host, rather than a hand-assembled integration written for the occasion.