File size: 6,516 Bytes
bf0fb33 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | # 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.
|