Proof

Two kinds of evidence, never averaged together.

Real estates through fixed stages

An estate is a real OpenTofu or Terraform configuration, pinned by commit, run through every active stage side by side with stock OpenTofu against the pinned emulator, and diffed. An estate is clear when every headline stage passes.

Core estates
25 of 26 estates behave like OpenTofu
  • Cold deploy: 26 pass, 0 fail, 0 not run
  • Migrate: 26 pass, 0 fail, 0 not run
  • Replan from nothing: 26 pass, 0 fail, 0 not run
  • No-op apply: 26 pass, 0 fail, 0 not run
  • Drift and reconverge: 26 pass, 0 fail, 0 not run
  • Rename: 26 pass, 0 fail, 0 not run
  • Remove a block: 25 pass, 1 fail, 0 not run
  • Change count: 25 pass, 0 fail, 0 not run, 1 stale (carried from an earlier run, not measured by the run the row records)
  • Replace with create_before_destroy: 25 pass, 0 fail, 0 not run, 1 stale (carried from an earlier run, not measured by the run the row records)
  • Crash between create and destroy: 1 pass, 0 fail, 25 not run
  • Teardown: 0 pass, 0 fail, 26 not run
  • Plan, review, apply: 26 pass, 0 fail, 0 not run
  • Greenfield apply: 26 pass, 0 fail, 0 not run
  • Strict profile: 1 pass, 0 fail, 25 not run
All estates
26 of 27 estates behave like OpenTofu
  • Cold deploy: 27 pass, 0 fail, 0 not run
  • Migrate: 27 pass, 0 fail, 0 not run
  • Replan from nothing: 27 pass, 0 fail, 0 not run
  • No-op apply: 27 pass, 0 fail, 0 not run
  • Drift and reconverge: 27 pass, 0 fail, 0 not run
  • Rename: 27 pass, 0 fail, 0 not run
  • Remove a block: 26 pass, 1 fail, 0 not run
  • Change count: 26 pass, 0 fail, 0 not run, 1 stale (carried from an earlier run, not measured by the run the row records)
  • Replace with create_before_destroy: 26 pass, 0 fail, 0 not run, 1 stale (carried from an earlier run, not measured by the run the row records)
  • Crash between create and destroy: 1 pass, 0 fail, 26 not run
  • Teardown: 0 pass, 0 fail, 27 not run
  • Plan, review, apply: 27 pass, 0 fail, 0 not run
  • Greenfield apply: 27 pass, 0 fail, 0 not run
  • Strict profile: 1 pass, 0 fail, 26 not run
kubernetes lane
2 of 2 estates behave like OpenTofu
  • Cold deploy: 2 pass, 0 fail, 0 not run
  • Migrate: 2 pass, 0 fail, 0 not run
  • Replan from nothing: 2 pass, 0 fail, 0 not run
  • No-op apply: 2 pass, 0 fail, 0 not run
  • Drift and reconverge: 2 pass, 0 fail, 0 not run
  • Rename: 2 pass, 0 fail, 0 not run
  • Remove a block: 2 pass, 0 fail, 0 not run
  • Change count: 2 pass, 0 fail, 0 not run
  • Replace with create_before_destroy: 0 pass, 0 fail, 0 not run, 2 n/a on this substrate
  • Crash between create and destroy: 0 pass, 0 fail, 0 not run, 2 n/a on this substrate
  • Teardown: 2 pass, 0 fail, 0 not run
  • Plan, review, apply: 2 pass, 0 fail, 0 not run
  • Greenfield apply: 2 pass, 0 fail, 0 not run
  • Strict profile: 2 pass, 0 fail, 0 not run

Behaviors proven: 1 of 14 stages have their representative-set fixtures passing against the tier-1 behavior matrix - a development-loop signal for contributors, not a coverage claim; it neither substitutes for the bars above nor gates anything on this page.

Estates above were last measured against different emulator pins: 25 against ghcr.io/lex00/floci@sha256:9ec3fa649177f64c17c299e3fd799cc774cc1e1b67db2bc20e27d1bc98d7c264, 1 against ghcr.io/lex00/floci@sha256:a39185cc3971d0188663d61043cb038dff1260d8a975b1aa72c4e2bb1feac3cb, 3 against ghcr.io/lex00/floci@sha256:0bbeb43075c9df9c7e06311cd4eec99a354594d304faa4fe5899b494a009d23d. The current pin is ghcr.io/lex00/floci@sha256:0bbeb43075c9df9c7e06311cd4eec99a354594d304faa4fe5899b494a009d23d; a row not measured against it is stale evidence, not a failure.

The stages cover the whole life of an estate: cold deploy by stock, migrate, replan from nothing, no-op apply, drift and reconverge, rename, remove, change count, replace, crash between create and destroy, teardown, plan then apply, greenfield, and the strict profile. A real-account certification run is recorded separately from the bars and counts toward neither.

Claims you can run

Each claim is a smoke scenario: Docker plus the local emulator, one to six minutes, exit 0 only when every assertion held. Every scenario also runs inverted: under BREAK=1 it manufactures the corruption the claim guards against and passes only by catching it.

#ClaimRun it~minAWSKUBERNETES
1Owned resources cannot fall out of plans unnoticedjust smoke no-silent-orphans2provenproven
2Contention settles at the platform API, never in a lockjust smoke no-self-managed-locks2provenopen
3Staleness costs reads, never resultsjust smoke staleness-costs-reads3provenopen
4Declaring the backend is the whole setupjust smoke backend-sets-itself-up1provenopen
5Recovery is a re-run, never surgeryjust smoke recovery-is-a-rerun2provenopen
6The roundtrip: one command in, one file outjust smoke roundtrip3provenopen
7Identity is a tag you can read and movejust smoke identity-is-a-tag3provenrestated
8Stock when you need itjust smoke stock-when-you-need-it3provenopen
9Unchanged is freejust smoke unchanged-is-free3provenopen
10The cache serves the whole estatejust smoke cache-serves-the-whole-estate2provenopen
11A count pool is a fungible setjust smoke count-is-a-fungible-set2provenn/a
12Carve by retagjust smoke carve-by-retag needs Go6provenproven
13The tag is the boundaryjust smoke the-tag-is-the-boundary4provenproven
14A plan costs its estate, not its accountjust smoke plan-cost-tracks-the-estate2provenrestated
15Apply exactly what was approvedjust smoke apply-what-was-approved4provenopen
16The boundary holds across provider configurationsjust smoke the-boundary-holds-across-regions2provenopen
17A record-only composite identity survives cache loss without a duplicate createjust smoke record-only-survives-cache-loss2provenopen
18A replaced object's shadow is not a second claimantjust smoke a-shadow-is-not-a-claimant3provenopen
19The boundary holds across accountsjust smoke the-boundary-holds-across-accounts2provenopen
20Scale: the estate boundary holds when the account is a terralithjust smoke plan-cost-under-foreign-load needs Go5provenopen
21The marker is a label: one tofu-estate label on a real clusterjust smoke k8s-greenfield2n/aproven
22No silent orphans on Kubernetes: a deleted block's object is found by its label and a controller's copies are never touchedjust smoke k8s-no-silent-orphans3n/aproven
23The label is the boundary: one admission policy fences every write to an estate's objects, and live-mv -from-estate is the governed relabeljust smoke k8s-the-label-is-the-boundary4n/aproven
24A custom resource binds by its natural key, carries the estate label and is swept by it, a block whose CRD the cluster does not serve is refused by name, and the plan carries the API server's own dry-run verdict on every planned object: a kubernetes_manifest block is found again by the apiVersion, kind, namespace and name inside its manifest, its object is created with tofu-estate in metadata.labels, an object whose block is removed is found by the sweep and proposed for removal, before the CRD is installed the plan refuses the block naming the kind, the apiVersion and the CRD to install, and every planned create or update is sent to the server with dryRun=All and its acceptance printed above the planjust smoke k8s-custom-resource3n/aproven

Every AWS cell is proven. The Kubernetes column is what the Kubernetes proof page explains.

Run one now

just smoke import

That stands a stock estate up, deletes its state file, and plans it empty from markers alone. Paste the README’s agent prompt to a coding agent and it runs the whole thing and reports each verdict line.

What it costs against stock

The price is not one number, because it is not paid on every run. It depends on what the run is doing.

A configuration with no live block

Nothing. Over the same estate, terraform plan, tofu plan and choudoufu plan issued exactly the same API calls. Lint, the refusals, marker stamping, discovery and the projection each sit behind a guard a missing live block turns off.

A plan of an adopted estate

At call parity with stock, or slightly under it. On a real account at 745 resources the two sides came in at 1416 calls against 1413 (d359210978), then 1449 against 1404 (02885d2fd6). The residual is a handful of calls that can be diffed action by action, not a percentage.

There is no wall-clock figure. The three real-AWS sessions that produced one were comparing a cached plan against an uncached one, and the page behind this one says why they are withdrawn rather than restated.

Adopting, auditing, or rebuilding identity

The estate-wide sweep is the real cost. It lists everything in the account that carries this estate’s marker and reads the address off what comes back: one tagging-API call per hundred tagged resources, plus a per-type native leg that was measured at 512 calls on a 79-instance estate (5ff7f43f5b) and does not shrink when an estate is sliced into several. A plan of an estate that has its own record store to narrow by does not pay it; a fresh estate, or one mid-migration, does.

What the cache buys

On a default plan, nothing, on purpose: the read pass is drift detection. On -refresh=false, an instance the run can vouch for is served from the cache and its reads are never made. Losing the cache costs a read; a stale cache cannot change a plan, and one scenario runs that experiment on every smoke.