# Validation report Recorded 2026-09-19; subsequent gate evidence is appended by date below. Latest historical verified Linux delivery at the time of the foundation report was **run 1402** on `4c2cc04ac47d37c6191a9ef02d4bbba716a930dc`. Native check history and later gate-specific results are kept separate. Results distinguish executed checks from pending Linux/cluster gates. ## M5.7 local publication - 2026-09-26 Added the single-writer local filesystem adapter and manifest v1 under ADR-0048. The implementation is in `include/evo/world/local_files.hpp` and `src/world/local_files.cpp`; `schemas/local-world-manifest.md` defines the durable bytes. The commit point is replacement of the inactive manifest slot after the referenced payload has been written, flushed, installed and directory-flushed. Recovery validates the snapshot and optional journal before returning a new store. FNV is only a corruption check; this is not host-loss durability or the M7 region ownership system. Executed on Windows x64 / MSVC 19.44.35207: - `tools/windows-check.ps1 -Preset release -Action check`: configure/build passed; 47/47 CTests passed with `NDEBUG`. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 and warnings-as-errors build passed; 47/47 CTests passed. - `tools/windows-check.ps1 -Preset asan -Action check`: build passed; 47/47 CTests passed. The Windows preset is not Linux ASan+UBSan evidence. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `git diff --check`: passed before commit. New coverage validates checkpoint/journal/recovery, exact compaction over a published journal, divergent-state rejection, exclusive writer lock, injected publication boundaries, partial-write/out-of-space outcomes, corrupt manifest and missing payload. Before-manifest failures recover the previous state; after replacement, reopen recovers the new state. Actual power-cut/disk-full behavior, POSIX syscall path, Linux CI/libFuzzer, and filesystem-controller flush guarantees remain unverified locally. There is no automatic orphan cleanup, production storage adapter, Kubernetes deployment or World0 change. ### M5.7 review corrections The follow-up review found that command high-water alone allowed a divergent checkpoint to replace an active journal. Checkpoint now compares its canonical bytes with the fully recovered journal result before compaction. Poisoned handles reject recovery; reopen resolves ambiguous post-replacement directory-sync failures. Interruption tests now use a different edited payload and compare recovered canonical state and debris across the commit point. Deterministic partial-write/out-of-space injection covers payload and manifest temporaries, including retry, and a directory sync failure hook verifies poison/reopen behavior. The injection models a partial write outcome; it is not a physical disk-full or power-cut test. Revalidated after these corrections on Windows x64 / MSVC 19.44.35207: - Release configure/build and 47/47 CTests passed. - clang-tidy analysis build and 47/47 CTests passed. - ASan build and 47/47 CTests passed. - clang-format and `git diff --check` passed. ## Tools and host - Windows NT 10.0.26200, AMD Ryzen 7 9800X3D, 8 cores / 16 logical processors. - MSVC 19.44.35217.0, CMake 3.31.6-msvc6, Ninja 1.12.1. - clang-format and clang-tidy 19.1.5 (Visual Studio LLVM tools). - kubectl 1.31.4 / Kustomize 5.4.2 for offline manifest rendering. ## Executed native checks | Command | Observed result | |---|---| | `./tools/windows-check.ps1 -Preset debug -Action check` | Configure/build passed; 5/5 CTests passed | | `./tools/windows-check.ps1 -Preset release -Action check` | Configure/build passed; 5/5 CTests passed under NDEBUG | | `./tools/windows-check.ps1 -Preset analysis -Action check` | clang-tidy/warnings-as-errors build passed; 5/5 CTests passed | | `./tools/windows-check.ps1 -Preset asan -Action check` | MSVC AddressSanitizer build passed; 5/5 CTests passed; this is NOT UBSan | | `./tools/windows-check.ps1 -Preset debug -Action format` | Passed with clang-format 19; repeated twice in one shell after helper fix | | `./build/release/evo-sim --seed 123456 --entities 8 --ticks 1000000 --verify-replay` | Exit 0; replay_verified=true; hash fab22c2e8ae1c379 | | `./build/release/evo-benchmark` | Exit 0; MSVC 1944 Release, seed 123456, 10000 entities, 1000 ticks, 0.0210666 seconds, hash 3bad6db1612cbd1 | | Git Bash `bash -n tools/ci/linux-check.sh` and `bash -n tools/ci/publish-image.sh` | Syntax checks passed; no Linux execution implied | | `kubectl kustomize deploy/kubernetes/dev` | Rendered Job, ServiceAccount and NetworkPolicy in evolution-dev; final render pins the verified run-1402 image | CTest covers the independently frozen 1000-tick fingerprint d61ad5bf0c928c76, seeded replay properties, malformed/semantic snapshot rejection, entity lifecycle, capacity/overflow, telemetry and CLI file continuation/alias protection. The expected-failure harness confirms tests remain active in Release. The benchmark is a single uncontrolled wall-clock observation, not a performance threshold or an MMO capacity estimate. Its initial compiler output accidentally used hexadecimal; the stream now returns to decimal and reports MSVC 1944. ## Gitea evidence The maintainer's [run 1399](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1399) on `8ab48d3a5639121693f5881b600482e870b49f05` completed successfully. API job records confirm verify (configure/build/CTest) and publish (Docker build/push) succeeded on runner theraborn-runners-runner-0, label ubuntu-22.04. This is evidence for the original workflow, not the expanded sanitizer/analysis jobs added in this change. Exact Linux tool versions and expanded-run results appear below; a runner label is not a compiler version. ## Limitations and next gates - Local Docker Desktop has no running Linux engine. Container checks must run on the configured Gitea runner; no local container success is claimed. - Expanded Linux GCC14/Clang19, ASan/UBSan, TSan and libFuzzer evidence is recorded below. TSan currently validates a sequential kernel, not future concurrency. - Sandbox process restrictions stalled native Ninja and blocked Git Bash signal pipes. Those attempts were stopped; checks reran successfully outside sandbox. - Repeated VsDevCmd initialization grew PATH beyond cmd's limit. The helper now reuses the matching x64 environment and deduplicates PATH; repeated checks pass. - The maintainer reports Argo setup, but this workspace has no Kubernetes context. No dev Job completion or cluster admission result is recorded yet. - No biology, network/load, durable server recovery or backup restore exists. Those remain M2, M7/M8 and later gates, not failing or passing foundation tests. Update this report with run URL, tested commit, image digest and Job result when those checks execute. Never overwrite a golden merely to make CI pass. ## Expanded Linux run 1400 [Run 1400](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1400), commit 9e412736d91ad103b7a951f99b811c629c5ac61e: GCC14 Debug and Release, Clang19 analysis and ASan/UBSan each passed 5/5 tests. Formatting passed. The seeded fuzz smoke completed 10000 cases with no reported failure. CMake 3.28.3, GCC 14.2.0, Clang/format/tidy 19.1.1, Linux 6.8.0-110-generic x86-64. Million-tick hash matched Windows (fab22c2e8ae1c379); benchmark hash matched too (3bad6db1612cbd1), with 0.0674131 seconds observed for 10000 entities * 1000 ticks on the CI host. TSan compiled but all executions failed before main: its runtime could not call personality(ADDR_NO_RANDOMIZE) inside the Docker build sandbox. The image job was skipped, as required. This is not recorded as a TSan pass. The follow-up isolates execution in a container with the narrowly constrained profile from ADR-0020; its result must be recorded after execution. ## Successful delivery run 1402 [Run 1402](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1402), commit 4c2cc04ac47d37c6191a9ef02d4bbba716a930dc: every job succeeded. The general checks reused Docker's valid cache for unchanged checked sources; their full execution also passed in run 1401. TSan executed all five CTests successfully in 2.71 seconds using the scoped profile and writable tmpfs outputs. Run 1401 had first exposed a non-root tmpfs permission error; setting explicit mode=1777 on these isolated scratch mounts fixed it. No test was disabled or ignored. The runtime image built, ran the restricted replay smoke test and was pushed to: `registry.aeternalisgames.com/aeternalis/aevolution:sha-4c2cc04ac47d37c6191a9ef02d4bbba716a930dc-run-6-1` Registry digest: `sha256:8fce2b462c9907f38d3fb832afeb70d0bff068dd832b2171e861186dbcb8e6b9`. The dev manifest pins this digest. This proves build/test/image delivery; Argo application mapping and Kubernetes Job completion remain unverified locally. ## M1.5 native ECS experiment Opt-in target evo-ecs-experiment (EnTT4 pinned in ADR-0021), based on 1c6e6e1 plus this experiment's changes. MSVC Release contract checks passed, including 72 seed/density/count combinations, hand-calculated arithmetic, canonical equality, restore continuation, retired-ID rejection, malformed snapshot checks and allocator balance. The final clang-tidy build/test passed after tightening the process-boundary diagnostic catch. MSVC ASan passed on the final source. Baseline Release CTest remained 5/5 and format-check included the experiment. No simulation rule/golden changed. Commands: configure release/analysis/asan with `-B build/ecs[-analysis|-asan] -DEVO_BUILD_ECS_EXPERIMENT=ON`, build target evo-ecs-experiment, then `ctest --test-dir -R ecs-experiment --output-on-failure`. Seven measured samples plus warmup are retained in results/ecs-msvc1944.jsonl; protocol, build observations and scope limits are in ECS_EVALUATION.md. The Linux experiment CI job is pending its first pushed run; no Linux experiment success is claimed yet. ## M1.5 Linux evidence [Run 1404](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1404), source bf7d60b7cd174736d38aea42616064e55e0c5f05: every job passed. The new ci-ecs stage explicitly prepared the pinned header/license, then built and ran the experiment under GCC14 Release, Clang19 ASan/UBSan and Clang19 analysis. All three contract invocations passed. Raw measured GCC samples are retained at results/ecs-gcc142.jsonl; all 56 fingerprints match corresponding Windows samples. No production rule or snapshot-format change occurred. This supersedes the pending Linux experiment note above. The final follow-up edits only record results and decision scope; production ECS adoption remains deferred. ## M1.6 sequential scheduler (2026-09-19) Native commands: `tools/windows-check.ps1 -Preset release -Action configure`, clang-format on changed C++ files, `cmake --build --preset release`, `ctest --preset release`; then `tools/windows-check.ps1 -Preset analysis -Action check`, `tools/windows-check.ps1 -Preset asan -Action check` and Release `-Action format`. All three configurations passed 5/5 CTests; clang-tidy and format-check passed. Tests execute under NDEBUG and cover six batch permutations across 32 seeds, an independent direct-lifecycle reference, ordered receipts, restore continuation, rejected conflicts and malformed admission, the 1,024-command boundary, full entity capacity and tick/ID exhaustion. Golden `d61ad5bf0c928c76` remains unchanged. The copy-and-commit implementation allocates before publishing world state and statically checks noexcept publication/receipt moves. Allocation-failure injection was not run. No scheduler throughput claim, concurrency validation, durable input journal or Kubernetes execution is implied. [Gitea run 1407](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1407) passed all four jobs for source `b620edfd6f8097172acf055402a24620cb078358`: Linux checks, the ECS experiment, separate TSan, and image smoke/publication. This closes the pending Linux validation for M1.6. The maintainer's independent dev image pin from `20e609d` was preserved during rebase. Kustomize renders the three expected dev resources successfully; no cluster execution is claimed. ## M1.7 spatial queries (2026-09-19) Release and MSVC ASan passed 5/5 CTests. Tests cover periodic-image reference comparison (32 seeds × 3 lifecycle/restore phases × 24 queries), hand-checked seams/corners/inclusive radii, empty/full capacity, invalid centers and maximum u32 radius. Queries leave snapshots unchanged; existing v1 goldens remain intact. Native commands use `tools/windows-check.ps1 -Preset -Action check` and Release `-Action format`. Initial analysis flagged an unnecessary test-helper vector copy; the helper now takes a const reference. Final analysis, Release, ASan and formatting passed after applying the helper's required line wrapping. Linux validation is recorded below. `build/release/evo-spatial-benchmark.exe` produced 72 measured records plus metadata in results/spatial-msvc1944.jsonl. One warmup and three samples per scenario; 1k/10k/100k entities, 128 queries, uniform/clustered positions, four radii. Timing includes result allocation, destruction and checksum work, excludes setup; no performance threshold. Desktop CPU load was not isolated. No cluster changes are required for this library increment. [Gitea run 1409](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1409) passed all four jobs for source `9b19509673d88683ee72e093e42534bfe151f928`: Linux checks, ECS regression, separate TSan and image smoke/publication. All 72 spatial benchmark checksums and match counts agree with Windows. Raw Linux measurements are in results/spatial-gcc142.jsonl; 24 native scenarios also have identical checksums across their three repetitions. No deployment manifest, rules version, snapshot format or golden was changed. ## M2.1 finite inventory ledger (2026-09-19) Native Release, analysis and MSVC ASan each passed 6/6 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and Release `-Action format`. Initial clang-tidy rejected the Element enum's oversized base type; changed to u8 and reran all configurations successfully. The new independent ledger test checks typed energy/mass separation, finite-source exhaustion, explicit heat transfer, intermediate overdraft, whole-transaction rollback, retry/duplicate action semantics, invalid reservoir IDs, maximum batch and reservoir counts, opening-total overflow and exact u64-limit transfers. 32 seeded runs × 31,250 transactions = one million transactions, each checked against independent reference balances, a replay branch and recomputed per-channel totals. This is transfer replay, not serialized recovery or an ecosystem run. Final ledger tests took 0.63s Release and 7.62s ASan locally; not controlled performance measurements. Existing particle goldens remain unchanged. Allocation-failure injection, durable ledger recovery and cross-ledger ownership are not tested or implemented. Rates and conversions are absent, so rounding residuals cannot occur in this transfer-only scope. [Gitea run 1411](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1411), source `8fd3591b0e37aaecf00a6410a5926745a031cb6f`, passed the Linux checks, ECS regression and separate TSan jobs. Each main Linux configuration passed 6/6 CTests. Ledger-suite times were 3.34s GCC Debug, 0.37s GCC Release, 2.46s Clang analysis and 8.78s Clang ASan/UBSan; these are CI test durations, not controlled performance benchmarks. The image smoke/publication job also passed, completing all four jobs. No deployment image pin was changed. ## M2.2 finite producer process (2026-09-19) Native Release, clang-tidy and MSVC ASan passed 7/7 CTests; format-check passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and Release `-Action format`. The producer suite compares hand-calculated ticks and 32 seeds × 1,000 ticks against a small-domain cumulative arithmetic reference, an independent replay branch and per-tick energy/element conservation audits. It covers invalid config/ticks with unchanged state, fractional capture/growth, efficiency endpoints, finite source exhaustion, all four limiting elements, zero capture, maximum u64 capture with 50% carried conversion, and maximum recipe and growth-cost multiplication. Particle goldens remain unchanged. Allocation-failure injection and tick-counter exhaustion were not exercised; the latter has an explicit guard but no arbitrary-state restore API. Tests use in-memory copies, not serialized recovery. No photosynthetic chemistry, metabolic model, database integration, throughput guarantee or deployment is claimed. [Gitea run 1413](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1413) passed all four jobs for source `af293b8b50cbb506a49dfff10c6cc92307e16aca`: Linux checks, ECS regression, separate TSan and runtime image smoke/publication. The initial push was delayed by a tool approval-review usage limit; retry succeeded after the maintainer resumed work. No deployment image pin was changed. ## M2.3 shared feeding community (2026-09-20) Native Release, clang-tidy and MSVC ASan each passed 8/8 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and Release `-Action format`. The new suite checks hand-calculated capture/feeding, producer-to-consumer and consumer-to-consumer predation, heat/waste outputs, terminal actor rejection, full-tick rollback, competing resource requests, duplicate sequence/consumer admission, per-channel intake caps, invalid actors, config/capacity limits and u64 assimilation endpoints. 32 seeds × 200 ticks compare reordered input batches, receipts, full balances and producer progress, with independently recomputed energy and elemental totals. Standalone producer and existing particle golden tests remain unchanged and passing. No serialized recovery, allocation-failure injection, spatial reach/perception, physical injury, corpse handling or persistent-world integration was tested or implemented. These are co-located synthetic process fixtures. [Gitea run 1415](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1415) passed all four jobs for source `b7dd466f57f385d6a8ffccfaa69f639077545587`: Linux checks, ECS regression, separate TSan and image smoke/publication. No deployment image pin was changed. ## M2.4 terminal inventory and decomposition (2026-09-20) Native Release, analysis and MSVC ASan passed 8/8 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and Release `-Action format`. Tests preserve corpse inventories on death, suppress producer activity immediately, reject repeated/invalid terminal events and roll back death with later invalid feeding. Sixteen seeds × 256 ticks compare a closed-form depletion reference, reversed terminal-event order, per-tick budgets, inventories and conservation. Additional cases cover shared corpse/waste limits, mixed and zero channel caps, u64-maximum inventories, diagnostic rollback, and returned nutrients funding producer structure on the next tick. The existing feeding, standalone producer, ledger and particle tests pass unchanged. This does not validate reaction chemistry, actual death causes, corpse scavenging, serialized recovery, allocation-failure injection or persistent history. There is no deployment change. [Gitea run 1417](https://git.aeternalisgames.com/dingo/AEvolution/actions/runs/1417) passed all four jobs for source `e17a9a7279d6bde736261c0c33abe46108e1f622`: Linux checks, ECS regression, separate TSan and image smoke/publication. ## M2.5 funded reproduction (2026-09-21) Native Release, analysis and MSVC ASan passed 8/8 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and debug `-Action format`. The first format run rejected three wrapped test declarations; clang-format 19.1.5 rewrote them and Release was rebuilt and rerun. Tests cover hand-calculated endowment and construction overhead, the endowment floor, per-channel insufficiency with abundant energy, zero and oversized investments, reserved slots rejected as feeding targets, corpses and ancestry subjects, the producer rejected as a parent, terminated and unknown parents, zero/duplicate sequences, two intents naming one parent, oversized batches, capacity exhaustion rejecting the whole tick, absent identity reuse after a child dies and decomposes, ancestry surviving both deaths, and construction endpoints of 0 and 1000 including a paid-for zero-endowment child. 32 seeds × 4 ticks × 2 births compare reversed intent order against balances, producer progress, birth receipts and independently recomputed conservation. A u64-maximum investment endows exactly and conserves. Default zero capacity leaves the M2.4 reservoir layout, feeding, producer, ledger and particle tests unchanged; golden `d61ad5bf0c928c76` is intact. Review of `c84a701` found one defect (2026-09-22): births validated each parent against the progressively modified candidate, so a child allocated earlier in the same batch was already active and could fund a second birth. Two generations could therefore appear in one tick, which ADR-0028 forbids. Eligibility is now fixed on entry to the reproduction phase, after terminal facts and feeding, and checked for every intent before any birth is applied. The contract itself was already correct and did not change. The regression test admits one intent whose parent is created by the preceding intent and requires `unborn_actor` with the entire tick unchanged; it was confirmed to fail against the unguarded implementation and to pass with the guard. The same pair succeeds across two ticks, recording the grandchild ancestry. All four native configurations were rerun after the fix. Allocation-failure injection, serialized recovery of states/parents/origins and long-run ecosystem behavior were not exercised. This fixture defines no reproductive strategy, fecundity, mutation, gestation, spatial placement or account ownership, and no deployment manifest or image pin changed. Linux validation is pending its first pushed run; no Gitea result is claimed for this increment yet. ## M2.6 measured ecosystem episodes (2026-09-22) Native Release, analysis and MSVC ASan each passed 11/11 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and debug `-Action format`. Formatting rejected 25 wrapped declarations on the first run; clang-format 19.1.5 rewrote them and Release was rebuilt and rerun. Three CTest cases are new: `ecosystem-contracts`, `cli-ecosystem` pinned to fingerprint `2cd4a15f9fbe9949`, and `cli-ecosystem-conflict`, which requires the CLI to reject `--ecosystem` combined with proof-run options. The suite checks a solitary founder that only ages, a hand-checked predation retirement, births exhausting exactly the reserved slots, tick-limit termination with survivors, configuration rejection, and two episodes interleaved without observing each other. Across 64 seeds it steps tick by tick, requiring that the driver never provokes a rejected batch and that conserved totals are identical at every tick, then replays each seed and requires an identical report. That ensemble advanced 22,804 ticks with 879 births, 730 predation deaths, 277 lifespan deaths and extinction in all 64 episodes, episode length 73 to 463 ticks. `build/release/evo-sim.exe --ecosystem --seed 0 --episodes 3000` advanced **1,093,007 ticks** in 1.34 s, with 41,138 births, 33,984 predation deaths, 13,154 lifespan deaths, extinction in all 3,000 episodes, episode length 50 to 497 ticks and fingerprint `130d7725c0dc8b16`. Deaths equal founders plus births exactly (6,000 + 41,138 = 47,138), so every process died once and no producer was grazed out: the producer always retains captured energy, so its whole inventory never reaches zero. The elapsed time is one uncontrolled wall-clock observation, not a performance threshold. Review of `eaf58f2` found one defect (2026-09-22): the CLI validated mode options in one direction only. `--ticks` was accepted and ignored under `--ecosystem`, and `--episodes`/`--tick-limit` were accepted and ignored without it, so a measurement script could exit zero while running the other workload. The parser now records which options were supplied and rejects any that do not belong to the selected mode, in both directions. Six CLI cases cover this; `cli-ecosystem-rejects-ticks` and `cli-episodes-require-ecosystem` are the two genuine regressions, while the entities, save and verify-replay cases were already rejected and add coverage. The remaining shared options were audited: `--seed` and `--output` are valid in both modes, and `--load` conflicts were already enforced. CTest is now 16 cases, all four native configurations were rerun, and `2cd4a15f9fbe9949` is unchanged. This measures arithmetic conservation and turnover, not ecological plausibility. Strategy constants, lifespans and the targeting rule are chosen inputs. There is no maintenance cost, starvation rule, perception, spatial gate, genome or heritable variation, so lineages differ only by founder strategy. Episode state is not serialized, allocation failure is not injected, and no population abstraction exists. Golden `d61ad5bf0c928c76` and every earlier suite are unchanged. No deployment manifest or image pin changed. Linux validation is pending its first pushed run; no Gitea result or cross-platform fingerprint agreement is claimed yet. ## M3.1 immutable genome record (2026-09-22) Native Release, analysis and MSVC ASan each passed 17/17 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and debug `-Action format`. Formatting rejected three wrapped declarations on the first run; clang-format 19.1.5 rewrote them and Release was rebuilt and rerun. `genome-contracts` is the one new CTest case, covering a new `evo::biology` library that nothing else links. Tests cover founder and descendant records, unordered drafts producing byte-equal canonical records, digests differing for identical capabilities from different origins, and every ancestry rule: zero identity, zero origin, zero development version, a zero parent, a self parent, two parents and a repeated parent. Schema rules cover an empty record, each of the three required capabilities removed in turn, a duplicate kind, an unknown kind, an unknown prerequisite bit, and both inclusive boundaries of all seven declared ranges accepted with one below and one above each rejected. Graph rules cover a declared prerequisite naming an absent capability, self, mutual and three-node cycles, a valid ordering using the same edges without the closing one, and a cycle closed by a mandated rather than a declared edge. Encoding tests cover the round trip, byte-exact re-encoding, truncation at every length from zero to one byte short, one trailing byte, an oversized buffer, a corrupted magic, and every single-byte corruption of the full record. Three cases reseal the checksum after editing so the later checks are reached rather than masked: a rewritten genome ID is caught by the digest, a future schema version fails closed, and non-canonical record order is caught as a duplicate kind. A parent count beyond the reserved room and a capability count beyond the schema are both refused before the corresponding region is read. Coverage limitation: in schema 1 every mandated capability is also a required one, so the presence half of the mandate check is reachable only through declared prerequisites, which is tested. The mandated edges do take part in the cycle closure, which is tested. A later schema that mandates a capability without requiring it would exercise the remaining branch; this is recorded rather than covered by a test that could not fail. Review of `8584eb1` found two defects (2026-09-22). First, `Genome` had implicit move operations, so moving one emptied the source's capabilities while leaving its identity, origin and digest intact: a record that still reported ID 7 but whose encoded bytes no longer decoded. That contradicted the documented invariant directly. The type is now copy-only, which suppresses the implicit moves so a move decays to a copy, and the invariant holds for every operation. The new move tests were confirmed to fail without the fix: the Debug and ASan builds exit 1 at runtime, and the Release build does not compile at all, because MSVC proves the moved-from comparison always throws and rejects the unreachable code under warnings-as-errors. clang-tidy then flagged the deliberate decaying moves in the tests as `performance-move-const-arg`; those two lines carry a NOLINT explaining that the decay is the contract under test. Second, the encoding tests compared the current encoder against the current decoder, so a coordinated change to layout or digest would have passed while breaking existing v1 records. A frozen 83-byte fixture now holds one schema 1 founder record. Every structural byte was verified by hand against schemas/genome-v1.md before being frozen: magic, both versions, ID 7, origin 1, zero parents, three records, kinds 0/1/5 with parameters 400/120/5000, and the `56 + 9N` length. The digest `9b2cdedef16ac87f` and the trailing checksum are computed values frozen alongside them. The fixture is asserted in both directions: the encoder must still produce those bytes, and the decoder must still read them into the expected record. It is a golden and must not be edited to make a test pass. No genome affects any simulation, and nothing links the new library except its own tests. The M2 process fixtures still duplicate founder strategies and do not read the record. Development, phenotype derivation, mutation, recombination, multi-parent heredity, migration between schema versions and any persistent genome archive are not implemented. The encoding is a local record format, not a network protocol or durable storage, and neither the digest nor the checksum is an authenticity claim. Golden `d61ad5bf0c928c76` and the ecosystem fingerprint `2cd4a15f9fbe9949` are unchanged. No deployment manifest or image pin changed. Linux validation is pending its first pushed run; no Gitea result is claimed yet. ## M3.2 development and phenotype (2026-09-22) Native Release, analysis and MSVC ASan each passed 18/18 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and debug `-Action format`. `development-contracts` is the one new CTest case, in the existing `evo::biology` library, which still nothing else links. No existing suite changed. The fixture genome uses a target size of 8,000,000 fg, which is an exact 20 micrometre cube at the declared density, so every derived value is hand-calculable and is asserted as a literal: structural mass 8,000,000, extent 20, surface 2,400, membrane mass 28,800,000, total 36,800,000 and maintenance 160,000 picojoules per tick. Half-built, damaged and maximum-size cases are hand-calculated the same way, including the 1e9 fg body that is an exact 100 micrometre cube with an uptake rate of exactly the reference surface, and the 999,999,999 fg body one cubic micrometre short of it, whose extent is 99. Determinism is checked over 45 growth and temperature combinations, each derived twice and compared, with more growth never yielding less structure. Damage is checked to change the phenotype while leaving the genome's encoded bytes and content digest identical, which is the M3.2 risk stated in the roadmap. Capability prerequisites are checked both ways: without the capability a component is zero at any size, and with it uptake scales with surface while movement speed does not. Thermal shortfall is checked inside tolerance, symmetrically outside it, and without the capability, and is confirmed to change no other derived value. Unsupported rule versions and out-of-range growth fail closed through both entry points. Plans are checked for the full funded step, for the exact largest affordable step one femtogram short of it, for no growth with no material, for a finished organism, for clamping the last step to the target rather than overshooting, and for never repairing damage. The declared flooring is pinned rather than hidden: a body whose mass floors to zero advances its growth counter for no material, which grants no structure because none exists at that size either way. Coverage limitation: the overflow guards are unreachable through the public API at schema 1 ranges, because the largest admissible genome produces a total mass of about 7.2e11 femtograms, eleven orders of magnitude below the u64 limit. They are kept as guards for later schema ranges and are recorded here rather than covered by a test that could not fail. No organism develops, nothing links the library except its own tests, and no inventory moves: a plan reserves nothing and pays for nothing. The transfer half of ApplyDevelopment, energetic budgets, repair, ageing, starvation, mutation and morphology are not implemented. Golden `d61ad5bf0c928c76`, ecosystem fingerprint `2cd4a15f9fbe9949` and the frozen genome fixture are unchanged. No deployment manifest or image pin changed. Linux validation is pending its first pushed run. ## M3.3 metabolic budgets (2026-09-23) Native Release, analysis and MSVC ASan each passed 19/19 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and debug `-Action format`. `metabolism-contracts` is the one new CTest case. `evo_biology` now links `evo::accounting` and `evo_processes` links `evo::biology`; no existing suite changed and no existing fixture reads genomes. Every budget is asserted as a hand-calculated literal against the same 20 micrometre cube fixture as M3.2: body 24,160,000 / 2,640,000 / 3,280,000 / 6,720,000 femtograms across C/N/P/other, maintenance 160,000 and movement 184,000 picojoules per tick, intake 240,000 picojoules and 2400/720/240/1440 femtograms, and a reproduction investment of 11,040,000 femtograms priced at 441,600 picojoules. Construction is checked to compose each compartment separately rather than by one blended ratio, and to agree exactly with what `plan_development` reports as material and energy. The non-uniformity the increment exists to demonstrate is tested directly. Doubling membrane thickness raises body matter to 65,600,000 femtograms, maintenance to 304,000 picojoules and the movement cost, shifts the carbon share upward because membrane is the carbon-rich compartment, and leaves intake limit, speed, assimilation and structural mass identical; the mass and maintenance ratios are asserted to differ, so no single multiplier could produce this. Growth is tested the same way: uptake follows surface while maintenance follows mass, and their ratios differ. Mass splits are checked to conserve at four awkward target sizes and four growth fractions, where every share floors and the last channel absorbs the remainder. An absent capability is checked to yield a zero budget rather than a default, and unknown rule versions and out-of-range growth fail closed. The genome-to-ledger path is exercised end to end: a derived `ConsumerConfig` drives a real `FeedingCommunity` tick, the ledger totals are identical before and after, and a bite one femtogram past the derived cap is refused by the existing M2.3 contract. The opening inventory is checked to be exactly the caller's. Review of `be71d4f` found one defect (2026-09-23): construction composed the mass difference rather than differencing the two composed bodies, which discards the rounding the existing body already carries. At target mass 1001 growing from 10 to 60, it funded C25 N7 P2 other16: the right total, but nitrogen and phosphorus one short each and other two over, so spending the budget could not produce the body the same rules derive. Construction is now the per-channel difference between the composed bodies, which funds C25 N8 P3 other14 for that case. Because the remainder rule is not monotone per channel, that difference can be negative on a channel, so construction became a transition with an intake and a release rather than a single requirement: a body growing from 13 to 14 femtograms acquires one carbon and one nitrogen while freeing one from other. The release is a rounding artifact bounded by a few femtograms, not excretion. A follow-up review found the affordability half of the same problem: a transition could require more of an element than was available, because the check compared net mass. A step growing a body from 13 to 14 femtograms nets one femtogram but acquires a carbon and a nitrogen while freeing one of other, and released other pays for neither. The environment now states availability per ledger channel rather than as one pool, since a pool cannot say that carbon is plentiful while nitrogen is not. `plan_development` keeps a total-mass bound, sound because net never exceeds gross but not an authority, and `metabolic_budget` narrows it to the largest step whose own intake fits channel by channel and reports the growth that step funds. That revises ADR-0031 and is recorded there. The affordability tests place a single femtogram in each channel in turn and require that no step needing a different element is funded, that nothing is acquired beyond what is present, and that the mass-only plan would have admitted the step; a carbon and a nitrogen together then fund it exactly. Across six target sizes by seven growth fractions by four stock levels, every reported intake is checked to fit the availability channel by channel and never to exceed the step the plan proposed. These tests were confirmed to fail with the per-channel check removed. A third review found the availability bound itself could wrap: summing four unrestricted u64 channels with 2^62 in each reaches exactly 2^64, so the total read as zero and both planning and budgeting refused growth that a billion femtograms per channel funded. The sum now saturates, which is also the right answer since no step can need more than u64. Regressions in both suites use that exact 2^62 case and a single saturated channel, and require the same step a billion per channel funds; both were confirmed to fail without saturation. The equivalent helper in `metabolism.cpp` is applied only to inventories derived from bounded phenotype masses, never to caller input, so it is left unsaturated rather than given a branch no test could reach. The invariant `held + intake - release == reached` is now asserted per channel for the reviewer's exact case, for the releasing case, across six target sizes by seven growth fractions by four material budgets, and across a forty-step walk from nothing to full growth where the accumulated intake and release are checked against the whole history. The net of every transition is also asserted to equal what `plan_development` charges material for. These tests were confirmed to fail against the previous implementation. Coverage limitation: as in M3.2, the overflow guards are unreachable through the public API at schema 1 ranges and are recorded rather than covered by a test that could not fail. The small integer helpers are duplicated between `development.cpp` and `metabolism.cpp` rather than shared through an internal header. No organism spends any budget: nothing consumes maintenance, movement or construction, and no starvation, death or repair rule exists. The constants are chosen for legible magnitudes, not balance. Golden `d61ad5bf0c928c76`, ecosystem fingerprint `2cd4a15f9fbe9949` and the frozen genome fixture are unchanged. No deployment manifest or image pin changed. Linux validation is pending its first pushed run; no Gitea result is claimed for any increment since `b01a824`. ## M3.4 seeded mutation candidates (2026-09-23) Native Release, analysis and MSVC ASan each passed 20/20 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and debug `-Action format`. `mutation-contracts` is the one new CTest case, in the existing `evo::biology` library. No existing suite changed. The eligible set for the founder fixture is pinned by hand rather than observed: nine operators, derived from the schema by the rules that make them eligible. Energy conversion and membrane can adjust either way, movement, ingestion, reproduction and thermal tolerance can be acquired, target size can adjust up but not down because its 9,999,999 step would fall below the minimum from 8,000,000, and no required capability can be shed. Over 2,000 seeds the offers are exactly that set and nothing else. Uniformity is checked to within a fifth of each operator's exact share, about six standard deviations for 8,000 offers across nine operators. That test was confirmed to fail when the draw was replaced by taking the first eligible operators, which is the shape a biased offering would take. The rejection sampling that removes modulo bias is correct by construction rather than test-verified: over nine bins with 64-bit draws the bias it removes is about one part in 10^18 and no test at this scale could observe it. That is recorded rather than claimed as covered. Stability is checked both ways: the same context always returns the same candidates, while a new event index, seed, stream or growth state returns a different draw. Selection is checked to refuse an operator that was never offered, a moved event index, a changed growth state, a tampered offer and a different parent genome, each with its own error. Boundary operators are checked to be absent rather than clamped at both ends of a range, and a capability another one declares as a prerequisite is checked to be unsheddable while the dependent capability itself remains sheddable. Every offered candidate is selected in turn and its successor checked to validate, to record parent 7, and to survive a decode; the reported maintenance and mass are checked to equal what `metabolic_budget` charges that successor. Review of `5497f4d` found one defect (2026-09-23): selection established a stale context by comparing regenerated candidate lists, which cannot establish it. Four of nine operators is only 126 distinct lists, so different contexts draw the same list routinely, and an offer from event 1 was accepted under event 239. An offer now records the parent's identity and digest and the context itself, and selection compares those directly before anything else. Because they then determine the draw, a list that still differs means the offer was altered, which is now its own error rather than a context having moved. The regression searches for a context whose draw collides with the offer's, asserts that such a collision exists rather than assuming it, and requires that selection still rejects it. It was confirmed to fail against the previous implementation. Rewriting the offer's recorded context to name the colliding one is checked to be accepted, and should be: those candidates genuinely are what that context draws, so the result is a legitimate offer for it rather than a forgery. Editing a candidate is checked to be caught as an altered offer. No organism mutates and no fixture calls any of this. Candidate count, context window, mutation cost as a game rule, inherited versus acquired expression, NPC mutation and recombination remain open and are not settled here. Golden `d61ad5bf0c928c76`, ecosystem fingerprint `2cd4a15f9fbe9949` and the frozen genome fixture are unchanged. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. ## M3.5 lineage retention (2026-09-23) Native Release, analysis and MSVC ASan each passed 21/21 CTests; formatting passed. Commands: `tools/windows-check.ps1 -Preset -Action check` and debug `-Action format`. `lineage-contracts` is the one new CTest case, in the existing `evo::biology` library. No existing suite changed. Retention is asserted as a property of the type, not only of its behaviour: four concepts check that the archive offers no `erase`, `remove`, `clear` or `prune`, with a std::map positive control so the checks are known to be live rather than vacuously true. An earlier attempt used bare requires-expressions, which MSVC diagnoses eagerly for a non-dependent type, and a std::vector control, which was wrong because `vector::erase` takes an iterator rather than a key; the concept correctly reported false and the control was corrected rather than the assertion weakened. A branching fixture of five genomes over three generations is used throughout. Tests cover a genome outliving both organisms that carried it with its record, ancestry, children and organism terminal ticks intact; ancestry and descendants resolving through a genome whose only carrier died; common ancestors for siblings, cousins, a genome against itself and two separate founders; refusal of a duplicate identity, a child admitted before its parent and a full archive; death being terminal against repeat, reversal and rebirth; and absence being reported for every lineage that has no living carrier, including one that gains a carrier again afterwards. The capacity case admits the full 4,096 genomes as one chain, checks that the refusal leaves every earlier record intact, and walks the 4,096-deep ancestry. The implementation was changed twice under clang-tidy rather than suppressed. `std::map` members made the archive's move potentially throwing, because MSVC's map move constructor allocates a sentinel node; sorted vectors replaced them, which also matches the rest of the codebase. A wrapper struct holding a `Genome` by value then had the same problem, because ADR-0030 made `Genome` copy-only, so genomes are now stored directly and identified by their own `id()`. The redundant per-genome carrier tally was dropped in the same change: carriers are counted from the organism records, so there is no second tally that could drift. Review of `8020347` found one defect (2026-09-23): the retention claim covered methods named like removal and nothing else, so `archive = LineageArchive{}` discarded every record, and assigning a copy taken before a death restored that organism's living state. Both forms of assignment are now deleted, which also makes the archive unswappable, and the copy constructor is declared so the implicit moves are suppressed and a move decays to a copy. Copying stays available because a clone removes nothing and GENOME_MODEL expects cloned-world rehearsals. The interface tests now cover assignment, replacement from a temporary and swapping as well as the named methods, each with a std::vector positive control, and check at runtime that a copy taken before a death does not disturb the original's terminal record and that a moved-from archive still holds everything. All four static assertions were confirmed to fail with the deleted assignments removed. Linux CI on `29ce255` reported one build blocker (2026-09-23), the first Linux result recorded since `b01a824`. GCC Release passed 21/21, then the Clang 19 analysis build failed: a bare `{1, 2, 3, 4, 5}` deduces `initializer_list` and the sign-changing conversion to each `std::uint64_t` element trips `-Wconversion` under `-Werror`. The literals are now unsigned. MSVC `/W4 /WX` does not diagnose this, and GCC's `-Wconversion` does not warn when a constant value is known to fit, so neither the local checks nor the GCC job could have caught it; only Clang did. Attempting to reproduce Clang's diagnostic locally through clang-tidy failed, because the warning flags are not honoured in its cl driver mode and no clang driver is installed on this host. The whole tree was instead audited by hand for the pattern: every other range-for over a braced literal list either deduces through `auto` or already carries suffixes matching its declared type, and this was the only instance. That audit is a one-off, not a check that will catch the next one; the standing gap is that no Clang or GCC compile happens on this host before a push. Nothing is serialized, so no history survives a process, and no fixture calls any of this. Terminal extinction is not claimed anywhere, durable retention and migration are M7 and M8, and NPC mutation remains undecided. Golden `d61ad5bf0c928c76`, ecosystem fingerprint `2cd4a15f9fbe9949` and the frozen genome fixture are unchanged. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. ## M3.6 genome ecology ensembles Executed on this Windows host (2026-09-23): Release configure, build and `ctest` 33/33; the analysis preset (clang-tidy 19, warnings as errors) built clean; the ASan preset configured, built and ran 33/33; `clang-format` 19.1.5 reported no violations after the new files were formatted. All four checks ran and passed on the committed tree. No Clang or GCC compile happens on this host, so the standing gap recorded for `29ce255` is unchanged and Linux CI remains the first Clang and GCC result for this increment. `evo-ensemble-tests` covers eight properties: that a derived strategy carries exactly ADR-0032's budget quantities and invents no margin, that divergence is reproducible and refuses its bounds rather than truncating, that conservation holds at every tick of every cell, that a run is reproducible and a different seed is not, that the archive ends holding exactly the founders and every organism that lived with no living carriers, that the two seed halves agree within the stated band, that each gradient axis alone changes the outcome, and that a thermally tolerant strategy keeps more scheduled life at the extremes. `evo-sim --ensemble` is pinned by fingerprint `c2b96c86101be628`, confirmed stable across three runs and distinct from a different seed's `8f88e72cf2715eac`. Three defects were found and fixed during implementation, all by measurement rather than by review. `EnsembleReport` and `CellReport` were default-initialized rather than value-initialized: both are aggregates whose vector members give them a non-trivial default constructor, which leaves the scalar counters indeterminate, and the episode total read as garbage. Both are now `{}`. The other two are findings about the model, and are recorded in ADR-0035 rather than tuned away. The header claimed the resource level entered both the derived strategies and the episode's nutrient pool. It does not enter the derivation at all: founders are derived fully grown, so their construction transition is empty and ADR-0031's per-channel `available` cannot reach intake, assimilation or reproduction investment. The comment was corrected rather than the code, because the code was right and the claim was false. The resource axis was then measured to be decorative at the original constants and non-monotonic once it was not. A ten-point sweep at the original fixture returned 41 to 45 organisms across three orders of magnitude of nutrients with identical tick totals and eight extinctions everywhere: every birth came from the opening endowment, because a body of 353,600,000 fg needed 73,776,000 fg of carbon to reproduce while feeding supplied 8,000 fg per tick before assimilation, or roughly 23,000 ticks against a 60-tick lifespan. Rescaling so a birth can be earned required pinning the investment fraction to the genome schema's floor of one per thousand, because intake scales with surface and investment with body mass, so the ticks needed to fund a birth fall only as the cube root of mass. That a reproduction is affordable only at the schema floor is a finding about the ADR-0031/0032 cost model and is now the second priority in STATUS.md. After rescaling, a sweep of 200 to 200,000 femtograms gave 45, 45, 45, 51, 61, 81, 44, 44, 42 and 42 organisms: a peak near 8,000 and a fall away on both sides. The mechanism is ADR-0026's feeding rule that a target may be bitten by only one consumer per tick, which caps community income at one producer bite however large the pool; scarcity empties the producer, consumers bite each other, and that concentrates mass into individuals that reach the threshold, while abundance spreads the same income too thin to fund a birth. The gradient test therefore asserts only that an axis moves the outcome, never a direction. An earlier draft of that test asserted `rich_organisms > lean_organisms`; that assertion held at the two chosen cells but implied a monotonicity the sweep disproves, so it was replaced rather than satisfied by picking two cells that flattered it. Coverage limits. The grid is four cells and the tests use eight seeds per cell, so every number describes this fixture and nothing wider. The split-half band (`high * 2 <= low * 3 + 2`) is a chosen tolerance, not a derived one. No organism mutates during an episode, so nothing here exercises in-episode divergence and NPC mutation stays open. The thermal penalty lives in the harness and no contract knows about it, so no contract test covers it. Nothing is serialized. The eleven new CLI tests are new-behaviour tests for a new mode, not regressions of a fixed defect; only the M2.6 bidirectional mode check they extend was ever a regression. They were confirmed to fail the run, which is what `WILL_FAIL` asserts, but each one was not separately confirmed to fail through the branch it names, so a rejection arriving from a different branch would still pass. Golden `d61ad5bf0c928c76`, ecosystem fingerprint `2cd4a15f9fbe9949` and the frozen genome fixture are unchanged, and ADR-0029's episode driver was not touched. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. Review of `89ad95b` found three defects (2026-09-24), each now fixed with a regression confirmed to fail against the unfixed code. The harness recorded a death for every organism still alive when an episode stopped. A one-tick run therefore reported zero extinctions while writing terminal death records for founders that had not died, and every such organism's watched time was added to the same total as a completed lifetime. Ending observation is not death, and ADR-0034 makes a recorded death terminal, so there was nothing for the archive to be terminal about. Survivors now stay living, are counted in `survivors`, and their watched time accumulates in `observed_ticks`, which is a lower bound on a lifetime the run never saw end. `deaths` and `lived_ticks` cover only organisms observed to die, and the two are never added together. The run and archive test now checks that deaths plus survivors equals every organism recorded and that a lineage is absent exactly when all its carriers were seen to die. A draw that produced a genome without the reproduction capability derived a zero reproduction investment, which ADR-0029's driver refused outright, so `--ensemble --seed 10` exited with invalid_arguments; seeds 12 and 15 were confirmed to fail the same way and seed 11 to succeed. Filtering such variants out before sampling was rejected as the worse repair: the measured set would then have been the fertile subset chosen by a guard, and an inability to reproduce is a result rather than a reason for exclusion. The driver now accepts the strategy and proposes no birth for it, since an empty investment would otherwise clear both reproduction bounds trivially and request a birth transferring nothing. ADR-0029 is amended rather than silently contradicted, and ADR-0035's claim that the driver does not change was corrected to say what did. Only configurations the driver previously rejected outright behave differently, so the M2.6 pin was expected to hold and was checked rather than assumed: `--ecosystem --seed 0 --episodes 32` still reports `2cd4a15f9fbe9949`, and the ecosystem, feeding and producer suites pass unchanged. The ecosystem test that asserted a zero investment is rejected now asserts the opposite fact, that such an episode runs and reports no births. A half's thermal shortfall was assigned rather than accumulated, so a field documented as a total across the half's episodes carried one episode's reading. Two episodes at 15,000 millikelvin reported 15,000 rather than 30,000. It now accumulates per episode. The tolerance test's expectations were per-episode readings and are now stated against the episode count, with an assertion that the count exceeds one so a sum and a single reading cannot look alike. `cli-ensemble` was repinned from `c2b96c86101be628` to `5ec59d390909b526`, confirmed stable across three runs and distinct from seed 7's `090b83efb85ae477`. This is a change in reported facts, not a test accommodation: survivors are no longer counted as deaths, the outcome record gained `deaths`, `survivors` and `observed_ticks`, and the shortfall is now a sum, so the previous value describes a report this build does not produce. The rationale is recorded beside the pin. Each fix was confirmed to be load-bearing by reverting it alone and rebuilding. Restoring the survivor-as-death behaviour failed the archive test at the survivor count and, when that test was run second, the dedicated regression at `deaths == 0`. Restoring the zero-investment rejection failed the sterile-strategy regression at `EcosystemEpisode::create`. Restoring the assignment of thermal shortfall failed the summation regression. One of my own expectations was wrong rather than the code: a one-tick episode's survivors include organisms born during that tick, watched for none of it, so observed time equals one tick per founder rather than one per survivor. The test now says that. Coverage limits unchanged from the increment above, with two additions. Censored lifetimes mean a run's mean lifetime is not computable from `lived_ticks` alone and no test asserts one. Across a run the archive now ends holding living carriers, which is accurate about what was observed and is not a claim that anything persists; nothing is serialized. ## M4.1 cohort state and ownership Executed on this Windows host (2026-09-24): Release configure, build and `ctest` 34/34; the analysis preset (clang-tidy 19, warnings as errors) built clean; the ASan preset configured, built and ran 34/34; `clang-format` 19.1.5 reported no violations. All four checks ran and passed on the committed tree. No Clang or GCC compile happens on this host, so Linux CI remains the first result for the new `evo::ecology` library. `evo-cohort-tests` covers six properties: that a cohort keeps exactly the fields it was given, that totals equal the summed classes, that two cohorts with identical totals but different structure are distinguishable, that every construction invariant is rejected by its own named error, that one habitat and genome holds one record, and that only the recorded owner under a current epoch may replace it. A sixth checks that a cohort names a genome the archive resolves ancestry for without storing that ancestry. Every guard was confirmed load-bearing rather than assumed. Each of the nine was removed in turn and the suite rebuilt and rerun: the duplicate, stale epoch, wrong owner, unowned reserve, residual bound, class ordering, empty class and class range guards each produced a failing run, and removing the overflow guard fails to compile, because the running totals then have no reader and the Release build treats that warning as an error. An earlier attempt at this sweep reported all nine as not load-bearing; that result was false and was discarded. The harness wrote to `/tmp`, which Git Bash and PowerShell resolve to different directories, so the mutation script was never found and the source was never modified. The sweep was rerun against an absolute path. Two defects in my own test code were found and fixed before the suite was trusted. The single-argument `CHECK` macro split on the comma inside a braced initializer such as `Owner{11, 2}`, which is a compile error rather than a silent one, and the macro is now variadic. More seriously, the rejection tests originally asserted on `.error()` alone, which is undefined when the call unexpectedly succeeded and would have let a removed guard pass quietly; they now check the failure first through a `refused` helper. A regex rewrite applied to make that change spanned lines and corrupted several positive assertions, so the test file was rewritten rather than patched. Coverage limits. Nothing here is serialized, so `schemas/population-v1.md` pins field meaning and invariants and there is no encoder, no round trip and no migration to test. The approximation bound is carried and never computed or checked, so no test asserts that aggregation is faithful; that is M4.5. Conservation between a cohort and the rest of the world is not asserted, because this type holds an inventory without participating in any transfer. Ownership is tested as a single-process invariant only: epochs make a stale writer fail locally and nothing here exercises fencing between workers, which is M7 and M10. Negative reserves are not representable at all, since every quantity is unsigned, so what the suite rejects instead is a declared state that would require one, and two static assertions record that the underlying types are unsigned. `max_cohorts` is enforced but not exercised at its limit, since installing 4,096 records would add nothing to what the duplicate and lookup tests already establish. No existing contract changed. The proof golden `d61ad5bf0c928c76`, the ecosystem fingerprint `2cd4a15f9fbe9949`, the ensemble fingerprint `5ec59d390909b526` and the frozen genome fixture are all unchanged, and the other 33 tests pass untouched. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. Review of `1c8b292` found two defects (2026-09-24), both fixed with regressions confirmed to fail against the unfixed code. Replacement checked the ownership epoch and nothing that ordered two writes made inside one. A record installed at tick 1,000 holding 50 picojoules could be replaced by its own earlier tick-900 record holding 100, restoring inventory the installed record had already spent, because within an epoch the two were interchangeable. A cohort now carries a revision that strictly increases within an epoch, and a repeated revision is refused as well as an older one, since a write has to be strictly later rather than merely not earlier. A newer epoch may restart the series, because re-acquiring ownership begins a new one. The interval boundary is checked independently of both, so neither advancing a revision nor re-acquiring ownership is a way to rewind simulated time. A later revision at the same boundary stays legitimate: that is a correction, not a rewind. The implicit move emptied a cohort's age classes while keeping its habitat, genome and owner, so a moved-from record was the invalid cohort `create` refuses to build and the registry accepted through a move what it rejects through construction. The type is now copy-only, which suppresses the implicit moves so a move decays to a copy. ADR-0030 made the genome copy-only for exactly this reason in M3.1; the precedent existed and was not applied when this type was written. Both fixes were confirmed load-bearing by reverting each alone. Removing the revision check fails the new ordering regression, as does removing the backward boundary check. Removing the copy declarations fails to compile in Release, and not because of the static assertion: with that assertion also removed, MSVC proves the code after `source.classes().size() == 3` unreachable, having established that a moved-from vector is empty and the check therefore always throws. That is a compile-time proof of the assertion rather than an execution of it, so the runtime path was checked separately under the ASan preset, where the same mutation exits 1. Coverage limits are unchanged from the increment above, with one addition. The revision is a caller-supplied counter, not one the registry issues, so nothing prevents a caller from choosing revisions that are unrelated to its own write order; what is enforced is only that the registry refuses a record that is not strictly later than the one it holds. Issuing revisions, and fencing between workers, remain M7 and M10. No existing contract changed. The proof golden `d61ad5bf0c928c76`, the ecosystem fingerprint `2cd4a15f9fbe9949`, the ensemble fingerprint `5ec59d390909b526` and the frozen genome fixture are unchanged. Linux validation is pending; no Gitea result is claimed since `b01a824`. ## M4.2 collapse to cohort Executed on this Windows host (2026-09-24): Release configure, build and `ctest` 35/35; the analysis preset (clang-tidy 19, warnings as errors) built clean; the ASan preset configured, built and ran 35/35; `clang-format` 19.1.5 reported no violations. All four checks ran and passed on the committed tree. No Clang or GCC compile happens on this host, so Linux CI remains the first such result. `evo-collapse-tests` covers seven properties: that a plan totals its members exactly and moves each member's whole reserve, that ages and the per-class reserve distribution survive the move without redistribution, that every ineligible state and every malformed request refuses the whole plan by name, that a committed collapse leaves the ledger's conserved total unchanged while emptying every member reservoir and crediting the destination, that every rejection leaves both the ledger and the registry exactly as they were, that one plan cannot be committed twice, and that a moved-from plan is still whole. All ten guards were confirmed load-bearing by removing each in turn and rebuilding: the ineligible, foreign, duplicate, self-destination, age classification, stale sample, occupied destination, empty class and commit ordering guards, and the copy-only declaration. Two needed a second pass. The first age mutation did not compile, which is not evidence about the test, so it was rewritten to make the class predicate always match, which places every member in the first class and is detected at runtime. Removing the copy declarations fails to compile in Release for the reason recorded for the cohort; with the static assertion also removed the same mutation was rerun under ASan, where it exits 1, so the runtime assertions are load-bearing independently of the compile-time proof. The commit ordering mutation is worth naming: moving the ledger transaction ahead of the destination check is detected, because a rejected conversion then leaves biomass in a reservoir nothing owns while the members are already empty. That is the dual-representation failure this milestone is named after, and the ordering is what prevents it rather than a comment saying it does not happen. One expectation of my own was wrong rather than the code. A replay of a committed plan was expected to report `destination_occupied`, but the staleness check ran first and reported `stale_plan`, which is equally true. Both are pure checks made before anything moves, so safety was unaffected and only the diagnosis differed; the destination check now runs first, because "this conversion already happened" says more about a replay than "the world moved". The ordering rationale is recorded beside it. `accounting::ReservoirId` and `accounting::Transfer` gained the defaulted comparisons that every other value type in the project already carries, so a plan's legs can be compared. This is additive, no behaviour depends on it, and ADR-0037's status was corrected to say so rather than claim no M1 change. Coverage limits. Completeness of the offered member set is not checkable here and is not checked: nothing establishes that the caller offered every member it had. Emptying a reservoir is not withdrawing the right to use it, since the ledger has no removal, so a later transfer could credit an emptied reservoir and no test asserts otherwise. The before-and-after property is demonstrated across rejections inside one process; there is no persistence, so a crash between the ledger transaction and the registry install is outside what an in-memory registry can show, and durable conversion sequences, escrow and replay stay M7 and M8. Plans are bounded to 256 members by the ledger's transaction limit and nothing coordinates several conversions. The ledger-failure and destination-unavailable branches are reachable only past bounds the tests do not build, so they are refused-by-construction rather than exercised. No existing behaviour changed. The proof golden `d61ad5bf0c928c76`, the ecosystem fingerprint `2cd4a15f9fbe9949`, the ensemble fingerprint `5ec59d390909b526` and the frozen genome fixture are unchanged, and the other 34 tests pass untouched. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. Review of `1a59b63` found one defect (2026-09-24), now fixed with a regression confirmed to fail against the unfixed code. Commit proved the destination reservoir existed and that the registry slot was free, but never that the reservoir was empty. A conversion into an occupied reservoir therefore succeeded and mixed inventory it had never sampled into the cohort's backing store, leaving the cohort's recorded reserve understating what backed it and the surplus owned by nobody. The reported case was reproduced against the unfixed code rather than assumed: gathering into reservoir 5, which the fixture already seeds with seven picojoules, commits successfully and leaves the ledger holding 67 against a cohort recording 60. A destination holding anything is now refused. The success test additionally asserts that the destination balance equals the installed cohort's reserve, so a cohort's reserve is the whole of its reservoir rather than a part of it, and the new regression asserts that the refusal leaves the ledger balances, the ledger action counter and the registry all exactly as they were, then that emptying the reservoir first makes the same plan committable. The check runs after the staleness loop rather than beside the other destination checks. Both run before anything moves, so this is a reporting choice and not a safety one: replaying a committed plan into a fresh registry would be refused by either, and that the members no longer hold what was sampled is the more useful answer than that the reservoir is occupied. The ordering rationale is recorded beside the check. The guard was confirmed load-bearing by removing it alone, which fails the new regression. An earlier attempt to add that mutation reported the guard as not load-bearing; the result was void and discarded, because a Bash heredoc had mangled the escaped newlines in the mutation script and the script failed to parse, so nothing was ever mutated. It is the second time this environment quirk has produced a false negative in a mutation sweep, and both times the printed output rather than the exit status is what revealed it. ## M4.3 interval accounting Executed on this Windows host (2026-09-24): Release configure, build and `ctest` 36/36; the analysis preset (clang-tidy 19, warnings as errors) built clean; the ASan preset configured, built and ran 36/36; `clang-format` 19.1.5 reported no violations. All four checks ran and passed on the committed tree. No Clang or GCC compile happens on this host, so Linux CI remains the first such result. `evo-population-tests` covers ten properties, and `evo-cohort-tests` gained two for the amendments. An interval with no flux advances the clock and submits no ledger transaction. Births change the population and leave the reserve untouched. Death, predation, immigration and emigration each move biomass once to the named counterparty with the conserved total unchanged. A loss exceeding the population or any one inventory channel is refused rather than clamped, including at the boundary of a single millionth of a member, while taking exactly everything is vacancy rather than refusal. A population below one member stays a population and its record stays installed. A declared result that does not match the fluxes is refused in both directions, for counts and for biomass. Empty and backward intervals, a foreign owner and a repeated revision are refused. A commit against a record that has moved on, or a reservoir that no longer holds what was counted, changes nothing in either the ledger or the registry, and one plan cannot be committed twice. The seeded ensemble runs twenty-four seeds of forty proposed intervals each, deliberately proposing losses unbounded relative to the cohort so that some must be refused. Every accepted interval is checked for the conserved total being unchanged and for the cohort's reservoir equalling its recorded reserve. The test asserts that both the accepted and the refused path actually occurred, so a change that made everything refuse, or everything pass, fails rather than looking clean. All fourteen guards were confirmed load-bearing by removing each in turn and rerunning: the two no-clamp guards, the two mismatch guards, the interval, owner, revision and counterparty guards, the three commit staleness guards, and the three amendments to the cohort record. The two clamp mutations are the ones worth naming, because they are the defect rather than a missing check: replacing the refusals with saturating subtraction, which is what a clamp is, is detected. Two of my own expectations were wrong rather than the code. The escrow arithmetic in the migration test was miscalculated: the reservoir receives two hundred matter and returns one hundred, so from seven it stands at a hundred and seven, not a hundred and ninety-seven. And the dwindling-population test shed all but one femtogram of the reserve while declaring a result that held none, which is a real `biomass_mismatch`; the test now sheds the whole reserve. That second one surfaced a genuine tension worth recording: a class reduced to a fraction of a member may hold no reserve, because ADR-0036 gives reserve to members and a fraction is not one yet, so that biomass has to go somewhere in the same interval. It is recorded in ADR-0038's costs rather than worked around. ADR-0036 was amended twice, and both were forced by this milestone rather than chosen. Threading the reservoir through each request instead of binding it to the record would have let a caller advance one cohort against another's store, and a balance comparison cannot distinguish two equal reserves, so the binding is a correctness fix and not tidiness. Vacancy is required because a decline to exactly zero was otherwise unrepresentable and the only way through would have been the clamp this milestone exists to refuse. `Cohort::vacant` is a separate factory precisely so that an empty class list in a draft stays an error. Coverage limits. Closure is checked and stability is not: an interval whose arithmetic balances and whose ecology is nonsense is accepted, and no test asserts otherwise, because comparing matched ensembles is M4.5. The declared age structure is not verified to be what ageing would produce, since that needs the within-class distribution the record discards; nothing here checks that members did not get younger. Emigration escrows into a reservoir nothing settles with. Ownership remains a single-process invariant. The overflow and ledger-failure branches are reachable only past bounds the tests do not build, so they are refused by construction rather than exercised. Nothing is serialized. The proof golden `d61ad5bf0c928c76`, the ecosystem fingerprint `2cd4a15f9fbe9949`, the ensemble fingerprint `5ec59d390909b526` and the frozen genome fixture are unchanged, and the other 33 tests pass untouched. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. ## M4.4 materialization Executed on this Windows host (2026-09-24): Release configure, build and `ctest` 37/37; the analysis preset (clang-tidy 19, warnings as errors) built clean; the ASan preset configured, built and ran 37/37; `clang-format` 19.1.5 reported no violations. All four checks ran and passed on the committed tree. No Clang or GCC compile happens on this host, so Linux CI remains the first such result. `evo-materialize-tests` covers ten properties: that a drawn member receives the floor share while the rounding remainder stays with the class, that a class drawn empty hands over everything it held, that neither a residual nor a member that is not there can be drawn, that taking everyone leaves a vacant record rather than an extinction, that ages come from the top of a class and are stable when regathered, that a round trip is exact at one member per class, that a coarse class conserves the total while smoothing individuals, that repeated oscillation never pays, that malformed draws and stale views are refused without changing anything, and that a moved-from plan is whole. The oscillation test runs twelve collapse and materialize cycles over three members of unequal reserve and asserts three things every cycle: the ledger's conserved total never moves, no member ever holds more than the largest starting member held, and no member is younger than the corresponding member of the previous cycle. Those three together are what stops a round trip being a way to heal or to reset age. It also ends by asserting every member has been pushed to a class ceiling, which records the cost of the conservative age rule rather than leaving it as a claim. Eleven guards were confirmed load-bearing by removing each in turn and rerunning. Two of them are the named risk rather than ordinary validation, and both are detected: rounding the share up instead of down, which creates biomass, and drawing ages from the bottom of the class instead of the top, which returns members younger than they were and makes oscillation profitable. The free-healing risk has two sources and only one is closed. The arithmetic source is prevented outright and tested. The other is the declared resolution itself: within a class members are indistinguishable, so a coarse class heals a starving member at a well-provisioned member's expense while conserving the total exactly. That is not fixable by accounting and is asserted rather than avoided, with a companion test showing a round trip is exact when each class holds one member. Reading conservation of the total as evidence that any individual is right would be a mistake this pair of tests exists to prevent. Coverage limits. Materialization is not claimed to be the inverse of collapse and no test asserts that it is beyond the one-member-per-class case. Nothing checks that a proposed draw is ecologically sensible. A full draw yields at most one unit per member more than a partial one, which is an ordering artifact bounded by the class count and is not separately tested at every count. Injury, fertility and incubation are not reconstructed because a cohort never carried them. Ownership remains a single-process invariant, emigration escrow is still unsettled, and nothing is serialized. The overflow and ledger-failure branches are reachable only past bounds the tests do not build. No existing behaviour changed. The proof golden `d61ad5bf0c928c76`, the ecosystem fingerprint `2cd4a15f9fbe9949`, the ensemble fingerprint `5ec59d390909b526` and the frozen genome fixture are unchanged, and the other 36 tests pass untouched. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. Review of `380d609` found two defects (2026-09-24), both fixed with regressions confirmed to fail against the unfixed code. Materialization treated an empty reservoir as an available one. A vacant cohort, or one simply holding nothing, still owns its store, so a draw could credit that store while the owning record went on recording nothing: the same inventory in two places, reached from the opposite direction to the destination defect found in `1a59b63`. Destinations are now checked against the registry's ownership as well as their balance, and the registry answers whether a reservoir is used rather than callers inferring availability from what it contains. The same hole existed on the collapse side in a worse form, and was found by checking whether the reported defect had a sibling rather than by being reported. Nothing verified that the destination reservoir was unowned, so the shared-reservoir rule added in M4.3 would have refused the install only after the ledger transfer had already run, leaving the members emptied and their biomass in a reservoir nothing accounted for. That is exactly the stranding the M4.2 ordering was chosen to prevent, defeated by a check that ran too late. Whichever registry step will follow a transfer is now proved to succeed before it, through new `may_install` and `may_replace` queries that `install` and `replace` themselves delegate to, so there is one rule rather than a restatement that could drift. The second finding was a functional gap the oscillation test had been hiding by discarding its registry every cycle. A full draw leaves a vacant record, which ADR-0036 retains because absence is not extinction, and collapse then refused that habitat and genome as occupied. A full materialization was therefore a one-way door out of a habitat: the lineage that had been there could never return. Collapse now repopulates a vacant record in place, continuing its ownership and revision series rather than restarting them, and a record that still holds a population is still refused, because merging two silently is not a conversion. The oscillation test keeps one registry for all twelve cycles and asserts the revision continues across each repopulation, so the round trip is exercised against the world it left behind. Four of the five new guards were confirmed load-bearing by removing each alone: the ownership check on both sides, the collapse pre-check ordering, and the repopulation path. The fifth is not, and is recorded rather than presented as tested. The `may_replace` pre-check in `commit_materialize` is unreachable given the checks before it: the installed record has already been proved equal to the one the plan was built from, and the plan's result carries the same habitat, genome, reservoir and tick with a strictly later revision, so the replacement cannot be refused. Removing it changes nothing the tests can see. It is kept because it is the structurally correct place for the guard and its sibling on the collapse path is genuinely reachable, not because it is exercised. An environment note for the record: a Bash heredoc containing apostrophes failed to parse, so the larger test edits in this increment were written to a scratchpad file and run from there. That is the third distinct way heredocs have mangled content in this project, after backslash escapes and `/tmp` resolving differently between shells. ## M4.5 resolution comparison Executed on this Windows host (2026-09-24): Release configure, build and `ctest` 38/38; the analysis preset (clang-tidy 19, warnings as errors) built clean; the ASan preset configured, built and ran 38/38; `clang-format` 19.1.5 reported no violations. All four checks ran and passed on the committed tree. No Clang or GCC compile happens on this host, so Linux CI remains the first such result. The increment adds no library code apart from one defect fix described below. One rule is written once and applied at both resolutions; the individual run gives it a member at a time and the aggregate run gives it a class average and multiplies by the count. The aggregate run sub-steps at one tick, so interval-length error is not confounded with averaging error, and interval-length error is therefore unmeasured. The control is the part that makes the rest mean anything. With one member per class a class average is that member, so the two runs must agree exactly; the test checks population and every channel at every tick over forty ticks, and checks the class count stays inside the sixty-four-class bound. Introducing a one-unit drift into the aggregate upkeep is caught by it, so the instrument was verified rather than assumed. Without this control a measured divergence would be indistinguishable from a transcription mistake in one of the two runs. Measured, and reported rather than smoothed into a tolerance. Class widths ten and fifty: the aggregate population survives ten thousand ticks, with population gaps of 250 and 375 parts per thousand and energy gaps of 24 and 43. Class widths twenty-five, one hundred and two hundred: the aggregate population reaches zero while the individual run sustains seventy-five members. That is a false extinction caused by resolution alone. The numbers are in `docs/engineering/results/resolution-equivalence-msvc1944.jsonl`. The collapse is not monotone in class width: twenty-five destroys the population and fifty sustains it. An earlier version of the test asserted that coarser is never better, and the measurement refuted it; the assertion was removed rather than the widths being chosen to make it hold, and the non-monotonicity is now asserted instead, because it is surprising and because the warning written around it could otherwise become wrong without failing. Five widths locate the effect and do not map it; no mechanism beyond whole-class starvation is claimed. Conservation was exact at every tick on both sides of all five runs, including the three whose populations died out. Four of five conserve perfectly and three are ecologically worthless, which is the clearest available demonstration of ECOLOGY_MODEL's point that conservation is insufficient ecological evidence. Two flaws in my own experiment were found and fixed before any number was believed. The aggregate model originally shifted class bounds every tick and opened newborn classes at the full declared width, which produced overlapping classes: the model being measured was not one a cohort record could represent, and the first numbers measured were therefore of a model the library could not hold. Newborns now extend the youngest class down while it is narrower than the width, keeping the structure contiguous and ascending, and every step of the aggregate run is now checked to construct a valid `Cohort`. The earlier figures were discarded. The comparison also found a real defect in M4.3. `plan_advance` checked affordability with arrivals added before losses were taken, but emitted the ledger legs with the outflows first. The ledger applies legs in sequence, so an interval affordable as a whole underflowed leg by leg and was refused at commit with `ledger_failure`: a fifty-tick interval shedding 10,480 energy against 6,950 held while drawing 13,080 in reproduced it exactly. Arrivals are now the first leg, matching the order the arithmetic was validated in. The fix was confirmed load-bearing by restoring the old order, which fails both suites, and a dedicated regression in `evo-population-tests` covers an interval affordable only with its arrivals. One existing test had seeded its escrow assuming the old order and was corrected, with its comment; that comment had asserted the old ordering was what made the interval fundable, which was true and is now true of the opposite order. Coverage limits. One genome, so the mixed-genome diversity case ECOLOGY_MODEL also asks for is untested. One model, one scarce axis, one initial distribution and one capacity, so every number describes this fixture. The control runs over tens of ticks because one class per age exhausts the class bound, while the measurement runs over ten thousand: the instrument is checked at a shorter horizon than it is used at. The asserted envelope bounds are round numbers above the measurement with room for platform variation, so they are a regression guard and not a theoretical limit. Interval-length error, crash behaviour at conversion boundaries beyond one process, distribution across owners and persistence are all out of scope here. The proof golden `d61ad5bf0c928c76`, the ecosystem fingerprint `2cd4a15f9fbe9949`, the ensemble fingerprint `5ec59d390909b526` and the frozen genome fixture are unchanged. No deployment manifest or image pin changed. Linux validation is pending; no Gitea result is claimed since `b01a824`. Review of `b4c3da5` found one defect (2026-09-25), now fixed with the controls extended to catch it. The two runs allocated contested breeding slots in different orders. The individual run iterated members in insertion order; the aggregate run walked classes as stored, which is youngest first. When eligible parents outnumber free slots that decides which parents reproduce, and it does so for a reason that has nothing to do with averaging, so the published divergence was not attributable to resolution. The control never reached the capacity boundary and so could not have seen it, which is the part that made ADR-0040's central claim unsupported rather than merely imprecise. The allocation order is now part of the stated rule, oldest first, honoured at both resolutions: classes partition ages, so the oldest class holds the oldest members, and ordering inside a class remains something only the individual run can see, which is a resolution effect rather than an implementation difference. A second control was added at the capacity boundary, where twelve eligible parents contend for one free slot. Both controls now compare the whole distribution of members rather than censuses. That change matters on its own: whoever breeds hands the same investment to a child either way, so every total agrees while the distribution does not, and a census-only control cannot see a different parent having bred. The reported probe diverging only by tick 44 is exactly that effect. The attribution was then verified by mutation rather than argued. Restoring the individual run's insertion order fails the new control; restoring the aggregate run's youngest-first order fails it; and the earlier one-unit drift in the aggregate upkeep still fails the first control. Since either allocation order alone fails, the divergence reported in the results file is attributable to averaging. One of my own attempts at the control was wrong and was caught by the same mutation sweep. The contested fixture first gave ages that descended with the index, on the reasoning that this made insertion order differ from age order; it does the opposite, since descending ages make insertion order identical to oldest-first, and the individual-side mutation passed. Ages now ascend with the index, so oldest-first disagrees with both the insertion order and the stored class order, and each mutation alone is caught. Had the sweep not been run, the new control would have looked like it established attribution while covering only half of it. The measurements were regenerated and are unchanged: the same five widths, the same two regimes, the same gaps. That is worth stating plainly rather than presenting as confirmation, because the finding was about what the numbers could be attributed to and not about their values. Coverage limit added. Attribution rests on the controls covering every stage where the two runs could order things differently. Breeding allocation is the only order-sensitive stage, and the environment is sized so intake never depletes it, which the fixture asserts rather than assumes. A future stage introducing another order-sensitive decision would need its own control before these numbers could be trusted again. ## M4.6 local validation - 2026-09-26 Base 55a728a plus working M4.6 changes. Integrated the prior agent's untracked `tests/fixtures/resolution_model.hpp`; no production library changes or format version changes. Existing contested-parent and round-trip controls remain active. - Native MSVC 19.44 Release configure/build and CTest: 39/39 passed. - Native analysis (clang-tidy 19, including fixture headers): build and 39/39 passed. Initial analysis found a throwing error-reporting boundary in the benchmark; replaced catch-handler stream writes with stdio diagnostics and reran successfully. - Native AddressSanitizer: build and 39/39 passed. Windows ASan does not cover UBSan. - clang-format 19 format-check passed, now including tests/*.hpp. Diff whitespace check passed. - Full Release benchmark: 15 scenarios, one warmup plus three measured repetitions per representation. Raw results and host/method caveats are in [AGGREGATE_BUDGET.md](AGGREGATE_BUDGET.md). All scenarios conserved every channel; none qualified across all scarcity inputs under the proposed research gate. - Linux CI, UBSan, target-server profiling and production deployment were not run. No World0 resources or user source documents were changed. The final exception-handler-only adjustment was compiled in analysis; Release and ASan benchmark targets were then rebuilt and their resolution tests rerun. No performance or model algorithm changed after the archived timing run. ## M5.1 local voxel contract - 2026-09-26 Added ADR-0042, the local voxel contract and dependency-free `evo::world`. No existing simulation golden, codec or runtime dependency changed. The earlier uncommitted M5-M9 roadmap expansion is preserved in the working tree. Executed on Windows x64 / MSVC 19.44 with the repository helper: - `tools/windows-check.ps1 -Preset release -Action check`: configure/build, warnings-as-errors and 40/40 CTest passed. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 build and 40/40 CTest passed. - `tools/windows-check.ps1 -Preset asan -Action check`: AddressSanitizer build and 40/40 CTest passed. Native Windows ASan is not UBSan coverage. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `git diff --check`: passed. New Release-active tests enumerate independent signed chunk intervals, all 299,520 logical cell ordinals across edges 8/16/32/64, envelope corners, each-axis invalid bounds including INT64_MIN/MAX and UINT32_MAX, metric coordinates and all valid positive fill numerators. Typed rejection is checked before reading expected values. No allocation/terrain-generation/performance claim is made for the address envelope. Linux GCC/Clang CI and UBSan have not been run for this increment. No container, Argo or World0 deployment occurred. M5.2 storage benchmarks remain the next task. ## M5.2 compact chunk comparison - 2026-09-26 Added `evo-chunk-layout`, Release-active CTest checks, ADR-0043 and the [measured report](CHUNK_LAYOUT_EVALUATION.md). No production world API, persisted format or simulation golden changed. Executed on Windows x64 / MSVC 19.44: - `tools/windows-check.ps1 -Preset release -Action check`: 41/41 passed. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 and 41/41 passed after fixing a multiplication-width warning and reserving edit input. - `tools/windows-check.ps1 -Preset asan -Action check`: 41/41 passed. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - Release `evo-chunk-layout`: completed; archived 180 measured samples after warmups. Independently checked matching initial/edited hashes across all layouts and repeats for each of 20 edge/fixture pairs. Full per-cell oracle checks also run internally. - `git diff --check`: passed. Memory figures are owned capacities, not RSS or true allocation peaks; encoding sizes are estimates, not a codec. See the report for excluded buffers and timing limits. Native ASan does not cover UBSan. Linux CI, R730xd benchmarking and Kubernetes execution were not run locally. No Argo/World0 deployment occurred. Next: M5.3. ## M5.3 deterministic abiotic generation - 2026-09-26 Implemented ADR-0044 in evo::world with a versioned inert material table and pure point/chunk queries. The fixture creates no biological state. No existing simulation version, golden or persistence codec changed. Executed on Windows x64 / MSVC 19.44: - `tools/windows-check.ps1 -Preset release -Action check`: 42/42 CTest passed. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 build and 42/42 CTest passed. - `tools/windows-check.ps1 -Preset asan -Action check`: 42/42 CTest passed. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `python tools/world_generation_reference.py`: computed the 12 frozen fixture fingerprints independently before C++ execution; all match in CTest. - `git diff --check`: passed. New tests cover 262144 point/chunk comparisons across signed seams, query order, stratigraphy, known/unknown materials, version/edge rejection and extreme addresses. Fingerprint bytes are explicitly little endian logical fields. Linux CI and UBSan were not run locally; no cross-platform execution result is claimed. No deployment or World0 state change occurred. Next: M5.4 bounded sparse chunk ownership. ## M5.4 bounded chunk ownership - 2026-09-26 Added CompactCells, a fixed-slot ChunkStore, revision-validated read tokens and conservative dirty pinning under ADR-0045. No cell edit, persistence, distributed lease or clean acknowledgement API was introduced. Existing goldens remain unchanged. Executed on Windows x64 / MSVC 19.44: - `tools/windows-check.ps1 -Preset release -Action check`: 43/43 CTest passed. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 build and 43/43 CTest passed. - `tools/windows-check.ps1 -Preset asan -Action check`: 43/43 CTest passed. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `git diff --check`: passed. The initial test oracle mixed unsigned local offsets with a negative integer literal; corrected to explicit int64 arithmetic. Analysis required explicit optional checks at reads/eviction and identified an integer-width expression in the test. One narrow use-after-move suppression exercises the explicitly guaranteed empty-void source. Final checks above ran after those corrections. Coverage includes palette counts through 256 then dense fallback, full logical cell equality, material/fill distinctions, move validity, extreme/far addresses, exact accounted budget boundaries, failed-load state preservation, slot pressure, clean regeneration, stale/foreign tokens and dirty eviction refusal. Counter exhaustion is guarded but not injected; no allocation-failure fault injector is claimed. Memory accounting excludes allocator/runtime overhead and is not an RSS cap. Linux CI/UBSan and target-host performance have not been run locally. No deployment or World0 change occurred. Next: M5.5 accounted transactional edits. ## M5.5 transactional excavation - 2026-09-26 Added bounded atomic excavation, finite per-material debris volume, full-payload retry identity and a 64-command replay ring under ADR-0046. Existing biology/world base goldens and persisted formats were not changed. Formatter coverage now includes private headers under src, including the shared chunk-state definitions. Executed on Windows x64 / MSVC 19.44: - `tools/windows-check.ps1 -Preset release -Action check`: 44/44 passed, including the final late-source-failure test and nonthrowing commit static assertions. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 build and 44/44 passed. After the final targeted additions, rebuilt analysis and reran `ctest --test-dir build/analysis -R world-edit-contracts --output-on-failure`: passed. - `tools/windows-check.ps1 -Preset asan -Action check`: 44/44 passed. After those additions, rebuilt ASan and reran the same targeted test in build/asan: passed. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `git diff --check`: passed. Coverage includes seam-crossing excavation, four chunks/64 cuts, partial fills, rock/regolith volume conservation, all-or-nothing capacity/memory/source failures, missing/stale revisions, duplicate/changed requests, malformed bounds and retention expiry. Late source failure verifies an earlier prepared chunk is not published. No allocator failure injection, revision exhaustion injection or crash recovery is claimed. The source/replacement commit operations have compile-time nonthrowing guards. Linux CI and UBSan were not run locally. These are typed volume transfers, not a validated density/mass/chemistry model. No deployment or World0 modification occurred. Next: M5.6 canonical snapshots/edit journals preserving geometry, debris and retry state. ## M5.6 canonical world snapshots and edit journals - 2026-09-26 Added ADR-0047, byte schemas, canonical snapshot/restore and detached atomic journal replay. State includes base versions, identity, membership, revisions, geometry, debris, successful edit count and exact bounded retry records. No existing golden or biological simulation format changed. New snapshot v1 has an independently encoded 132-byte empty fixture from tools/world_snapshot_reference.py. Executed on Windows x64 / MSVC 19.44: - Release configure/build and 46/46 CTest passed on the final source/tests. - Analysis configure/build (clang-tidy 19) and 46/46 CTest passed after explicit size/iterator conversion fixes. Final history-corruption additions rebuilt and passed both tests selected by `ctest --test-dir build/analysis -R world-codec --output-on-failure`. - ASan configure/build and 46/46 CTest passed. After final size/iterator/golden and history-corruption additions, rebuilt ASan and reran both world-codec tests: passed. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `python tools/world_snapshot_reference.py`: generated independent golden bytes; encoder equality and decoder acceptance pass in CTest. - `git diff --check`: passed. New coverage includes 65-edit history rollover, deterministic continuation, historical retry receipts, exact re-encoding, snapshot+journal replay, wrong predecessor/final state, every fixture truncation, oversized/trailing data, version/identity/budget rejection, recomputed-checksum geometry/debris/receipt/revision/history corruption, and a deterministic 128-input semantic fuzz smoke. The fuzz harness mutates valid fixtures and repairs checksums so validation below the envelope is exercised. Linux libFuzzer/UBSan jobs are wired for 10000 cases but were not executed locally. Native Windows ASan is not UBSan. Full-size throughput, allocation-failure injection and crash-atomic files remain unverified/later gates. Codecs write no files, clear no dirty flags and issue no durable acknowledgements. No Argo/World0 operation occurred. Next: M5.7 local snapshot/journal publication, compaction and recovery. ## M5.7 review and M5.8 bounded world proof - 2026-09-26 Reviewed a2a12fdc696c005bd3feb496f6efcdc58c28262c against the three prior findings. Committed-journal compaction compares exact recovered canonical state; poisoned handles refuse recovery; interruption tests use changed payloads and include partial write failures. No new blocking finding identified in that correction's scope. M5.8 adds ADR-0049, evo-world-proof and world-process-restart CTest. It launches fresh prepare/compact/verify processes for three workloads, checks all cells and conserved debris independently, compares canonical bytes, enforces frozen hashes and checks clean regeneration. Existing formats and simulation goldens are unchanged. Executed on Windows x64 / MSVC 19.44: - tools/windows-check.ps1 -Preset release -Action check: 48/48 passed, including the final source with frozen hashes and nonthrowing boundary diagnostics. - tools/windows-check.ps1 -Preset analysis -Action check: clang-tidy 19 and 48/48 passed. Initial widening-conversion and exception-boundary diagnostics were fixed. - tools/windows-check.ps1 -Preset asan -Action check: 48/48 passed. - tools/windows-check.ps1 -Preset release -Action format: passed. - Five independent Release process workflows passed; medians/ranges and exact accounting/payload sizes are in WORLD_PROOF.md. Measurements preceded only the equivalent size_t constant and error-reporting correction; no success-path workload, snapshot or algorithm changed. - git diff --check: passed. CTest integrates the same frozen expectations into existing Linux CI, but this turn did not execute Linux, UBSan, physical power-cut, target-server or cluster checks. ASan is not UBSan. Process restarts are graceful; M5.7 fault injection remains separate coverage. No production durability or planet capacity claim. No Argo or World0 operation occurred. Next: M6.1 units and environmental coupling. ## M6.1 environmental units and coupling - 2026-09-27 Added ADR-0050, ENVIRONMENTAL_UNITS.md, checked local habitat geometry, exact mass concentration/water saturation and rational pJ/tick integration helpers. No field storage, density converter, source scheduler, gameplay or snapshot format changed. Terrain volume still cannot be credited as biological mass. Executed on Windows x64 / MSVC 19.44: - `tools/windows-check.ps1 -Preset release -Action check`: 49/49 passed. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 and 49/49 passed. - `tools/windows-check.ps1 -Preset asan -Action check`: 49/49 passed. - After strengthening independent balance sums, open-boundary and rollback tests, reconfigured each preset, rebuilt `evo-environment-units-tests`, and ran `ctest --test-dir build/ -R '^environment-units-contracts$' --output-on-failure`: passed in Release, analysis and ASan. Final code-only adjustment was an explicit cstddef include; CTest registration was grouped with other world tests. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `git diff --check`: passed. Coverage includes each invalid box axis, zero/maximum inputs, exact dimensional examples, concentration/type separation, dry/saturated/excess water, multiplication and addition overflow, invalid denominators/residuals, and 78,660 repeated-addition oracle comparisons of split versus combined intervals. The closed/open accounting example uses a finite boundary reservoir, independently sums balances and verifies rejected overdraft leaves all balances unchanged. Documentation's large terrain mass example was checked using exact BigInteger division (1e21 / 65535). Linux/UBSan and target-cluster checks were not executed locally; existing CI includes the new CTest. There is no new concurrency requiring TSan work. Helpers do not enforce owner identity, interval deduplication or residual persistence; those remain explicit M6.2-6.7 obligations. No deployment or World0 operation occurred. Next: M6.2. ## M6.2 optional environmental fields - 2026-09-27 Added ADR-0051, FieldStore, field snapshot v1 and its byte schema. Optional water, N/P, organic matter/energy, incident-energy and heat channels have explicit finite openings. Material defaults specify water capacity only. Uniform baselines with optional 64-site pages preserve absence versus zero. Same-channel local transfers stage replacements before commit and persist a strictly increasing command watermark. There is no resource setter, site regeneration, cross-compartment or organism credit. Executed on Windows x64 / MSVC 19.44: - `tools/windows-check.ps1 -Preset release -Action check`: 50/50 passed on final code. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 and 50/50 passed on final code. - `tools/windows-check.ps1 -Preset asan -Action check`: 50/50 passed on final code. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `git diff --check`: passed. Initial build diagnostics corrected explicit aggregate initialization and bit widths. The hostile fixed-underlying-type enum test has a narrowly scoped analyzer suppression with rationale; actual channel validation remains exercised. Tests cover uniform/sparse/varying memory, page seams and release, exhausted sources, source/capacity/budget/stale-command rollback, absent/present-zero restore, cross-field conserved-channel overflow, independent dense transfer continuation and all ten fields at 4096 sites. Maximum logical snapshot is 630880 bytes. A separately constructed 170-byte absent-field fixture checks canonical schema bytes. Every truncation of a 260-byte fixture, invalid/old versions, identity, malformed/resealed mappings and quantities, oversized snapshots and 256 repaired-checksum mutations are exercised. Memory observations are in ENVIRONMENTAL_FIELDS.md; accounted bytes are not RSS. Existing terrain/simulation formats and goldens are unchanged. Field snapshot v1 is a buffer codec, not LocalWorldFiles publication or combined terrain/biology durability. Rate sources and their interval/residual persistence are not enabled. Linux/UBSan, target-host performance, allocator-failure injection and cluster recovery were not executed locally. Existing Linux CTest CI includes the new test. No deployment or World0 operation occurred. Next: M6.3 read-only environment views. ## TSan world-proof scratch mount correction - 2026-09-27 The supplied Linux TSan log failed world-process-restart at CMake MAKE_DIRECTORY, before launching any proof phase. Its build-local output path had no writable mount in the read-only test container; Testing and cli-integration already had mounts. Added the matching 16 MiB, mode-1777, noexec/nosuid tmpfs for `/source/build/tsan/world-proof`. Container user, rootfs, network, capabilities and seccomp restrictions are unchanged. Documented all test scratch mounts in deploy/README.md. Executed `ctest --test-dir build/release -R '^world-process-restart$' --output-on-failure` after configuring the Release preset: passed on Windows. `git diff --check` passed. The workflow mount path was checked against the CMake test's TEST_DIR. No C++ changes or new sanitizer claims. Local Docker CLI exists, but docker version could not connect because the dockerDesktopLinuxEngine named pipe is absent. Consequently the corrected Linux TSan container invocation requires confirmation in Gitea CI; it was not run locally. No application deployment or World0 changes. ## M6.3 read-only environment views - 2026-09-27 Added ADR-0052 and a bounded canonical footprint query with typed mass/energy, exact concentration/moisture, habitat resolution, explicit caller tick, field watermark and sampled chunk revisions. FieldStore gained read-only identity and capacity accessors. Views own copied samples and retain private non-owning store/ chunk tokens for freshness checks. Existing formats, versions and goldens are unchanged. Executed on Windows x64 / MSVC 19.44: - `tools/windows-check.ps1 -Preset release -Action check`: 51/51 passed on final code. - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 and 51/51 passed. Removed an ineffective move of a trivially copyable sample after the initial analysis diagnostic. - `tools/windows-check.ps1 -Preset asan -Action check`: 51/51 passed on final code. - `tools/windows-check.ps1 -Preset release -Action format`: passed. - `git diff --check`: passed. Tests cover negative/positive chunk seams, input permutation, missing site/chunk, absent versus zero/unrequested fields, all moisture statuses, invalid masks and footprints, exact quantities/ratios, maximum 256-site footprint with all ten fields, and unchanged terrain/field snapshots after queries. Freshness checks cover changed tick, restored foreign stores, successful versus rejected field transfers, global field invalidation, unrelated terrain activity, sampled dirty marking, excavation and eviction/reload. The query never loads missing chunks or authorizes consumption. Linux/UBSan/TSan and cluster execution were not run locally; existing CI includes the new CTest without additional scratch mounts (this test writes no files). Host tick/store pairing and single-owner execution are explicit preconditions. ChunkStore does not yet bind a world identity, so coherent field/terrain pairing cannot be independently authenticated by this view. Combined ownership, reservation, atomic inventory transfer and retry outcomes remain M6.4. No deployment or World0 operation occurred. ## M6.4 atomic environmental transfers - 2026-09-27 Executed on Windows x64 with the installed Visual Studio toolchain: - `tools/windows-check.ps1 -Preset release -Action check`: build and 52/52 CTests passed (NDEBUG). - `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy/warnings-as-errors build and 52/52 CTests passed. - `tools/windows-check.ps1 -Preset asan -Action check`: AddressSanitizer build and 52/52 CTests passed. - `tools/windows-check.ps1 -Preset release -Action format`: passed. New environment-transfers-contracts exercises last-stock contention, fresh versus stale/foreign views, exact retries, changed-payload refusal, expired command IDs, command exhaustion, late-leg rollback, account and water capacities, admission overflow, separate owner/field allocation budgets, and 100 batches checked against independent expected balances across all ten compartments. No golden changed. This evidence covers local in-memory atomicity. Coupled snapshots, allocation-failure injection, process crash recovery and biological lifecycle integration are not claimed. Linux/UBSan/TSan were not run locally; their existing Gitea jobs remain required CI evidence. No cluster workload or World0 state was changed. ## M6.5 prerequisite review - 2026-09-27 Documentation-only review identified contradictory source-persistence sequencing in ADRs 0050/0051 and 0053. ADR-0054 proposes a resolution; it is not accepted or implemented. `git diff --check` passed. No source, public API, test, schema or build configuration changed, so builds/sanitizers were not rerun for this proposal. The M6.4 validation above remains historical evidence, not M6.5 completion evidence. ## M6.5a coupled resource codec - 2026-09-27 ADR-0054 accepted by the maintainer. Added resource envelope v1 without changing nested terrain/field formats or existing simulation goldens. Rates are still disabled; source configuration/residuals and biology join the later M6.5c fixture envelope. Executed Windows checks: - Release check: 52/52 CTests passed with NDEBUG. - Analysis check: clang-tidy/warnings-as-errors build and 52/52 CTests passed. - ASan check: 52/52 CTests passed. - After tightening restore to require all mapped chunks already in the snapshot, Release and analysis rebuilt and environment-transfers-contracts passed again; the ASan full run includes this final adjustment. - Release format target passed. Codec tests cover empty history, 66 transfers crossing the retry-ring boundary, canonical restored bytes, exact/conflicting/expired retries, equivalent continuation, all truncation lengths, checksum errors, recomputed-checksum invalid version/counts/ amounts, identity mismatch and each budget. Initial compilation caught missing codec error enum entries; corrected before the passing runs above. No Linux/UBSan/TSan, disk crash, allocation-failure injection or cluster validation was performed locally. Buffer round trips are not durable publication. M6.5b-d remain. ## M6.5b process contract - 2026-09-27 Documentation-only segment: accepted ADR-0055 and ENVIRONMENTAL_PROCESS.md define versioned fixture conversions and the narrow process/world ownership boundary. Inspected M2 producer/feeding implementations, their tests and ADRs, M3 metabolic budget contract, and M6 resource APIs before specifying the adapter. Executed independent PowerShell arithmetic checks for the documented fractional capture/efficiency sequence, nutrient-limited growth and per-channel feeding split; all passed. `git diff --check` passed. These are specification checks, not runtime integration tests. No C++/CMake/schema change; builds, CTest and sanitizers were not rerun for this documentation segment. M6.5c/d must supply executable evidence for rollback, source exhaustion, temperature limits, lifecycle and restored replay. ## M6.5c persisted environmental community - 2026-09-27 Implemented the one-habitat/two-actor fixture and envelope v1, preserving source identity/rate, residuals, last funded interval, lifecycle, resources and 64 exact input/report receipts. Restore replays receipts from a historical anchor, validates reports and compares the final state. Scalar candidate staging commits without allocation; the world layer checks capacities and conserved totals before publication. Executed Windows x64 checks: - Release check: 53/53 CTests passed, NDEBUG enabled. - Analysis check: clang-tidy/warnings-as-errors build and 53/53 CTests passed. - ASan check: 53/53 CTests passed. - After final tight-budget and continuous/restored comparison additions, analysis ran all 53 tests again; Release and ASan rebuilt and the two environmental transfer/community tests passed again. - Release format check passed. No existing golden changed. Coverage includes hand-calculated capture/growth/feeding, source disabled/unfunded, frozen residuals, inclusive temperature gates, terminal producer, whole-tick rollback, exact/conflicting/expired retries, eight deterministic input sequences through 90 ticks, continuous versus restored bytes/reports, every truncation length, corruption, recomputed-checksum invalid config/anchor/report/count/state, identity and budgets. M6.5d remains the broader adversarial, long-run and cost qualification gate. The supplied Gitea log shows GCC 14 Release rejecting transfer_codec.cpp with -Werror=free-nonheap-object in the vector reserve/push_back path. Changed that writer and the new process writer to exactly sized buffers, checked writes and final cursor validation. No warning suppression or resource format change. The next Gitea run must confirm Linux: Docker's Linux engine was unavailable locally; WSL Ubuntu exists but has no g++/g++-14, CMake or Ninja. No toolchain installation was attempted. No local Linux/UBSan/TSan or cluster result is claimed. Initial native static analysis flagged an unspecified enum base and integer widening in a size constant; both corrected before the passing analysis runs. No disk/host-loss recovery, biological maintenance, reproduction or player/offline progression added. ## Environment-view optional guards - 2026-09-27 The supplied Linux clang-tidy-19 log rejected five optional field accesses in `tests/environment_views_tests.cpp` with bugprone-unchecked-optional-access. Three had no presence check; two relied on CHECK, whose throwing helper is not recognized as a control-flow guard by this analysis. All five now use required_field, which explicitly throws on absence before returning a reference. The rule remains enabled; production code, formats, expected values and NDEBUG behavior are unchanged. Executed native analysis, Release and ASan builds plus the targeted `environment-views-contracts` CTest in each preset; all passed. Release format check and git diff --check passed. Full suites were not repeated for this test-only fix. Linux clang-tidy/libstdc++ confirmation remains with the next Gitea run; native analysis is not claimed as a reproduction of the Linux diagnostics. ## M6.5d environmental qualification - 2026-09-27 Added the environmental-qualification CTest and optional `--long` driver. It tests admission/capacity/overflow boundaries, each missing recipe resource, efficiency endpoints, consumer temperature gates, recomputed-checksum mutations, a u64-max trace and deterministic paired continuous/restored simulations. No runtime change. See [ENVIRONMENTAL_QUALIFICATION.md](ENVIRONMENTAL_QUALIFICATION.md) for detailed coverage, exact commands, long-run output, machine and measured memory/timing. Executed Windows checks: - Release configure/build/check: 54/54 CTests passed. - Analysis configure/build/check: clang-tidy/warnings-as-errors and 54/54 passed. - ASan configure/build/check: 54/54 passed, including tick exhaustion. - After adding the final tick-exhaustion case, Release and analysis rebuilt and environmental-qualification passed again. A constant-expression integer-width diagnostic in the new test was corrected before that final analysis run. - Release format and git diff --check passed. - Final Release `evo-environmental-qualification.exe --long`: 16 x 65536 logical ticks and paired continuous branches passed; 2097152 advances, 329231 bites, matching snapshots and conserved totals. Reported fingerprint 93a9f9b296caac36. Native M6.5 qualification is complete; no new Linux/UBSan/TSan or R730xd/cluster run was available locally. CI must confirm the committed test on its toolchains. No source-rule, schema, golden or deployment change. ## M6.6 retained corpse resources - 2026-09-27 Rules/envelope v2 now support trusted terminal facts for either fixture actor, retained corpse inventory and bounded tagged decay. This is an in-memory process checkpoint, not durable region publication or gameplay mortality. Rule v1 and its canonical bytes are preserved; no golden was replaced. Config/input extensions are rejected under v1 rather than silently omitted. New tests cover pending death plus feeding rollback, terminal actor rejection, shared per-channel caps in ID order, exact transfer destinations, partial decay, zero caps, water headroom, restored duplicate/conflicting/stale requests, permanent terminal state, consumer-corpse nutrients feeding a surviving producer next tick, every v2 byte truncation, and checksum-repaired invalid lifecycle/history fields. Eight 90-tick cases compare retained balances against independent cumulative-quota formulas, with restore at ticks 17, 65 and 90 and exact conservation every tick. Commands: tools/windows-check.ps1 -Preset release/analysis/asan -Action check; -Preset release -Action format; git diff --check. The initial suites found the older negative test's rules=2 was now valid; it now rejects unsupported rules=3. Final results are recorded below after all processes complete. Release long qualification again ran 16 x 65536 logical ticks, 2097152 paired advances, and produced unchanged v1 fingerprint 93a9f9b296caac36. Snapshot size remains 30615 bytes in that v1 case. Owner size is now 20152 bytes (formerly13400), including bounded extension receipts; budget admission uses sizeof dynamically. No new Linux/UBSan/TSan or R730xd measurement is claimed. Linux CI remains a separate verification step; local Docker Linux engine/toolchain is unavailable. Final native validation: Release 54/54 (3.66s), clang-tidy analysis 54/54 (13.37s), ASan 54/54 (46.72s), format check and git diff --check passed. M6.6 is natively qualified; the next gate is M6.7 interval scheduling. No deployment was changed. ## M6.7 local environmental intervals - 2026-09-27 ADR-0057 and ENVIRONMENTAL_SCHEDULING.md define the stateless interval adapter. Admission validates world/frame, fixed quantum, completed process/field revision, ordered endpoints, at most 64 ticks and an exact input count. Each process tick is atomic; execution failure explicitly returns the committed prefix and failing tick. No new scheduler state, snapshot format, biology rule, dependency or deployment. Tests compare 130-tick streams under rules 1 and 2 against direct execution using batch widths 1/3/17/64, flattened report equality and final canonical snapshots. Every batch pauses without mutation and restores before continuing. Admission cases include foreign/stale boundaries, quantum mismatch, missing/extra input, 65-tick backlog, u64-max backlog and reversed intervals. Failure at first, middle and final tick preserves precisely the committed prefix, then restores and resumes to the uninterrupted result. The existing valid u64-max checkpoint now also tests scheduler pause and wrap refusal. Partial success is intentionally not a whole-batch transaction; callers must inspect failure and committed count. Executed tools/windows-check.ps1 -Preset release/analysis/asan -Action check: Release 54/54 (6.44s); clang-tidy analysis 54/54 (14.20s); ASan 54/54. After making the optional failure access explicitly guarded, rebuilt Release and reran both environmental CTests: 2/2 passed. Analysis/ASan include that final guard. Release format-check and git diff --check passed. Tests retain NDEBUG checks. Linux/UBSan/TSan CI confirmation remains pending; native validation does not claim a Linux or target-server run. Next is M6.8 integrated ecological qualification. ## M6.8 integrated environmental qualification - 2026-09-27 Extended the existing qualification executable; no runtime, schema or golden changed. Complete evidence and reproduction commands are in [ENVIRONMENTAL_SLICE_QUALIFICATION.md](ENVIRONMENTAL_SLICE_QUALIFICATION.md). - tools/windows-check.ps1 -Preset release -Action check: 54/54 passed (4.06s). - -Preset analysis -Action check: clang-tidy and 54/54 passed (18.57s). - -Preset asan -Action check: 54/54 passed (60.83s); qualification itself 12.83s. - -Preset release -Action format and git diff --check passed. - Release evo-environmental-qualification.exe --long passed: existing v1 long fingerprint unchanged, plus 5120 v2 episodes/655360 logical ticks/1310720 paired advances. Full-cycle assertions, checked E/C/N/P/other totals, separate water, residual ranges, stable resource residency and restored retry equality passed. - Three integrated execution/snapshot/restore cost samples were collected on the developer machine. Concurrent analysis/ASan work is disclosed in the report. M6 is natively qualified for the bounded synthetic scope. Linux CI/UBSan/TSan, R730xd measurements and persistent server recovery are not claimed. The local Linux toolchain/Docker engine remains unavailable. Next: M7.1 durability contract. ## M7.1 region durability contract - 2026-09-27 Documentation-only gate: ADR-0058, REGION_DURABILITY.md and logical region-commit schema. Reviewed existing M6 process/resource codecs and scheduling contracts, LineageArchive public API and retention tests, individual genome codec, separate population/particle interfaces, persistence architecture and ADRs 0013/0016. The audit identifies complete M6 state and missing archive/binding/host state. Full checkpoint batches are selected; semantic events alone are not recovery. Verified new contract relative links (2 resolved) and all eight ADR sections; git diff --check passed. Reviewed the crash matrix against upload, fenced DB publication, ambiguous commit, ACK, recovery and clone boundaries. Those rows are future executable acceptance tests, not fault-injection results from this gate. No C++/CMake/schema codec implementation changed, so build/sanitizer suites were not rerun. M6.8's recorded native checks remain the latest executable evidence. No database, object storage, Kubernetes access or deployment was performed. M7.1 design gate is complete. M7.2 must evaluate/pin dependencies and exercise real migrations; M7.4 must implement additional ancestry state closure before M7.9 can claim lineage recovery. No retained-history or World0 requirement was relaxed. ## M7.2 PostgreSQL bootstrap - 2026-09-28 - Windows Release configure/build/CTest passed 54/54 (24.17s); format passed. - Built checksum-verified PostgreSQL/libpq 18.6 from source in WSL Ubuntu. - GCC14 Release, clang19 analysis (clang-tidy warnings-as-errors), and clang19 ASan/UBSan optional adapter builds and real private-database integration passed. Tests cover parameter separation/NULL, rollback, duplicate SQLSTATE, u64 range and fractional rejection, runtime-role denial, deadline closure, result bounds, backend termination, clean/repeated migrations, failed migration rollback, unknown versions and changed checksums. Expected SQL errors are negative tests. - Fixed analysis enum-size warning and migration rejection exit status during qualification; reran all three final configurations successfully. - clang-format19 dry-run passed for all three new C++ files; bash -n passed for preparation, migration, integration and publish scripts. ldd found all psql dependencies: libpq, libc/libm and OpenSSL (matching tooling image packages). - Docker Linux engine is unavailable locally. Container build/smoke and Gitea remote checks are configured, not claimed as executed. No cluster, external DB, TLS endpoint or Kubernetes Secret was accessed. TSan was not rerun: adapter has one caller-owned I/O thread and introduces no concurrent execution. The adapter is separate from the headless kernel. Region fencing, publication, ambiguous durable commit reconciliation and crash recovery are later M7 gates. Only clean-to-v1 and exact-v1 restart are supported migration paths at this gate. ## M7.3 fenced region ownership - 2026-09-28 - Windows MSVC Release configure/build/CTest passed 55/55, including the new portable `region-lease-contracts` test. Repository clang-format 19 check passed. - WSL Ubuntu (GCC 14.2.0; clang 19.1.1; PostgreSQL/libpq 18.6 source build): GCC14 Release, clang19 analysis (clang-tidy warnings-as-errors) and clang19 ASan/UBSan builds of `evo-postgres-tests` each passed `tools/ci/postgres-check.sh` against a fresh private cluster. The first analysis build flagged two unchecked optional accesses and two unreserved vectors. These were fixed and all three configurations were rerun after formatting. - Real-database coverage, as the runtime login rather than SET ROLE: - Denied (42501): table read/write, provisioning, the internal check function, and object creation. A hostile search_path is ignored. - Busy, forged-holder, stale-epoch and released-lease rejections; epoch non-reuse. - 1..64 tick delta; predecessor mismatch; exact-retry detection via the head. - 1 s database-time expiry and successor acquisition; paused stale writer fenced locally and by the database. - A writer queued 1.3 s on the lease row lock is rejected after expiry. - A 100 ms renewal deadline under lock (unknown) fences locally before a successor acquires. - 64 two-thread acquisition rounds with exactly one winner and consecutive epochs; 32 racing head advances with exactly one winner. - Epoch and sequence exhaustion. - Migrations tested: clean->v2, repeated v2 no-op, v1->v2 upgrade, and failed 0001 rollback. Superuser and missing runtime roles are refused with no schema left. Unknown v3, changed v2 checksum and changed v1 checksum are refused. - Mutation sensitivity (scratch copies only): replacing post-lock `clock_timestamp()` with `now()`, removing the lease check from head advance, and disabling the busy check each made the suite fail at the expected test. - Local Unix-socket latency, 200 samples per operation in each final run: - p50 about 0.61-0.74 ms and p99 about 0.8-1.15 ms for acquire, renew, advance and release. - Max up to 2.8 ms under analysis/ASan builds. These are local numbers, not remote TLS or cluster measurements. - Not executed: Docker/Gitea CI, remote TLS endpoints, Kubernetes Secrets, real pod kill, real network partition (a lock wait plus client deadline stands in for it), VM freeze and TSan. The contention threads each own a separate connection; libpq is uninstrumented. ### M7.3 review fixes - 2026-09-28 - P1: an attribute-only runtime role check let a login inheriting `pg_write_all_data` update `evolution.region_leases` directly. The CI script reproduces that UPDATE first. `apply.sql` now audits effective privileges on every run (the v2 migration file and its checksum are unchanged). Rejected, each with a rollback: - a runtime group inheriting `pg_write_all_data` on a fresh database (no schema left); - that grant on the login, and on the group WITH INHERIT FALSE; - a PUBLIC table grant, EXECUTE on the internal check function, and a CREATEDB login. The restored configuration passes again. - P2: `valid(LeasePolicy)` now bounds each term by the duration before any arithmetic. `acquired` validates the duration before computing a deadline. `renewal_unknown` ignores durations above 60 s and fences on non-positive ones. New tests use `milliseconds::max()` and `min()` for every field. Built against the previous source under clang19 UBSan, they reproduce the reported signed overflow (`9223372036854775807 + 2000`). - Reran Windows CTest 55/55, the repository format check, and GCC14 Release, clang-tidy analysis and ASan/UBSan private-PostgreSQL suites: all passed. ## M7.4a checkpoint publication - 2026-09-28 - Windows MSVC Release configure/build/CTest passed 56/56, including the new portable `region-checkpoint-contracts`. It covers: - golden byte offsets and round trips; - malformed and unsupported manifests, including u32 values above 255 that must not truncate onto supported enums; - chain rules; - payload identity, tick, quantum, corruption and budget checks; - 24-tick continuation equality after restore. The repository clang-format 19 check passed. - WSL Ubuntu, with GCC 14.2.0, clang 19.1.1, PostgreSQL/libpq 18.6 and OpenSSL 3.0.13-0ubuntu3.15, running as uid 1000 so permission faults were really exercised. GCC14 Release, clang19 analysis (clang-tidy warnings-as-errors) and clang19 ASan/UBSan each passed `tools/ci/postgres-check.sh`. - Analysis initially flagged `performance-enum-size` on the u32-based profile/durability enums. They are now u8 with explicit decoding of values above 255 as unknown. All three configurations were rerun. - New real-database/filesystem coverage: - SHA-256 vectors (NIST "", "abc" and the 448-bit message) and agreement with PostgreSQL `sha256()`. - Object store: rejects root symlinks, creates 0700 namespaces, puts are idempotent, never overwrites differing content, ignores temporary leftovers, and detects byte flips, symlinks, truncation and growth. Size bounds and write-permission failure are also covered. - Genesis provisioning and duplicate refusal; three batches (16/64/16 ticks); a 65-tick batch refused before upload. - Recovery from a new store handle is byte-identical and continues 44 ticks identically to an uninterrupted reference. - The build allowlist is enforced by the host and by the database. - Upload failure leaves the head unchanged. A fenced publication leaves a verified orphan, and recovery ignores it. - Missing and corrupt payloads quarantine; restoring the object recovers. - Owner edits to a manifest (23514) and head repointing (23503) are refused. With the constraint dropped, recovery still detects the edit, and the constraint is restored afterwards. - Unknown regions are never created. - Lease tests were ported to manifest publication. They additionally cover malformed manifests, a quantum change, an unretained build, a future rules version and a globally reused commit ID. - Migrations: clean→v3, repeated no-op, v1→v3. v2 with existing heads fails closed and stays at v2. The audit rejects EXECUTE on provisioning and SELECT on commits. Tampered v2/v3 checksums and an unknown v4 are refused. - Mutations, run on scratch copies with the source restored afterwards: removing the predecessor-digest check, the lease check, the version/quantum continuity check or the retained-build check in SQL, or the host manifest re-digest, each failed at the expected assertion. - Local fixture measurements: payloads of 22775 and 37367 bytes. - Release publication took 3.6-4.8 ms per batch; analysis 5.5-6.7 ms; ASan about 10.5 ms. - Manifest publish p50 was about 0.74-0.91 ms. These are local socket and local disk only. - Not executed: Docker/Gitea CI, a remote object store or PVC, power-loss fsync semantics, read-back verification fault injection, process kill, and TSan. ## M7.4b lineage checkpoint profile - 2026-09-28 - Windows MSVC Release CTest passed 57/57, including the new `lineage-region-contracts` and extended lineage and region-checkpoint contracts. The repository clang-format 19 check passed. - WSL Ubuntu (GCC 14.2.0, clang 19.1.1, PostgreSQL 18.6, OpenSSL 3.0.13): - The Linux `checks` build set (separate build dirs) passed CTest 57/57 in each of GCC14 Debug, GCC14 Release, clang19 analysis and clang19 ASan/UBSan. - The PostgreSQL integration suite passed 2× Release, 2× analysis and 5× ASan/UBSan. - Archive codec coverage: - canonical encoding regardless of admission order, including a child with a smaller ID than its parent; - checksum, magic, version, count cap, length and organism-count framing; - genome damage, unknown genome, invalid alive/died forms, death before birth, reordered organisms (non-canonical) and a child encoded before its parent; - a full 4096-genome/65536-organism round trip at 2,543,648 bytes. - `LineageRegion` coverage: - closure refusals: missing, identical or dead binding; low high-waters; stray living organism; future birth; archive death while the community is active; - the death recorded at tick 20 in the same advance; a refused tick changes nothing; - restore plus 36 continuation ticks identical to the original; - container, binding, envelope and archive damage refused. - Profile 2 coverage: - the 4,268,144-byte cap is asserted in C++ and enforced by SQL (the maximum is accepted, +1 refused); the profile-1 1 MiB+1 is refused; - mismatched profile/history is EVL06; - lineage publish (death included), recover and continue, and a second publication; - the environmental path refuses a lineage predecessor before upload; - the database refuses a profile switch; - a host of the other profile reports unsupported. - Migrations: clean→v4; v1→v4; v3 with a committed genesis upgraded to v4 with the commit retained; v2 heads still block. Tampered v2/v3/v4 checksums and an unknown v5 are refused. - Mutations (restored afterwards), each failing at the expected line: removing the SQL profile/history continuity check (store test 392), the living-set closure check (lineage region 58), or death recording (lineage region 78). - Flake found and fixed. The ASan PostgreSQL suite failed intermittently: 1 of 3, then 1 of 5 runs, at the queued-writer and expired-renewal assertions. - Cause: a 4-minute probe measured WSL2 stepping CLOCK_REALTIME back 470-596 ms every ~32 s (3.66 s total, roughly 1.5% versus CLOCK_MONOTONIC). - PostgreSQL `clock_timestamp()` follows that wall clock, so a 1.2 s local sleep could be under 1 s of database time. - Tests now poll `clock_timestamp() >= expires_at`, holding the row lock where relevant. Afterwards the suite ran 5/5 under ASan. - The fencing logic itself was unchanged; the requirement is recorded in ADR-0060. - Local measurements, Release: - manifest publish p50 0.72 ms and p99 1.24 ms; - checkpoint publication 3.5-5.0 ms for 23-37 KiB payloads. - Not executed: Docker/Gitea CI, remote storage, process kill, reproduction within a batch (the fixture has none), durable history rows (M7.5) and TSan. ## M7.5 durable batch outcomes - 2026-09-28 - Windows MSVC Release CTest passed 58/58, including the new `region-batch-contracts`: - recorder sealing at a death or at 64 ticks, early flush, confirm matching, and a refused tick recording nothing; - trace round trip, size (19,552 bytes at 64 ticks), range, contiguity and header binding; - decision order, uniqueness, range, and refusal of unknown values. The manifest v2 golden layout, v1 decoding and batch-evidence structural rules were also covered. - WSL Linux: the `checks` build set (GCC14 Debug and Release, clang19 analysis, clang19 ASan/UBSan) passed CTest 58/58 each, and the repository format check passed. - The first PostgreSQL clang-tidy build flagged a returned const-reference parameter and two unchecked optional accesses; all three were fixed. Final PostgreSQL suites: Release 2 runs, analysis 2, ASan/UBSan 4, all passing. - Real-database coverage: - Durable death at tick 20, with decisions and outbox rows in the same commit. - Outbox: redelivered, acknowledged true then false, then empty; invalid limit and unknown rows refused. - A lost response retried with identical bytes returns the same receipt and records no second death; resolution says committed. - A changed manifest or changed decisions conflict (EVL07/22023). Other regions and unknown IDs resolve as conflict and absent. - A repeated death is EVL08. A forged same-size block, a partial block and a reordered block are 22023. A gap is EVL03. None of these moved the head or decisions. - A 300 ms client timeout while queued on the lease row became unknown; once the lock cleared the server committed, resolution returned committed and the retry was idempotent. - A terminated orphan request resolved as absent, and the same bytes were retried and committed. - A missing predecessor payload is `predecessor`. State advanced outside the batch fails replay. Batches from the wrong predecessor and unsealed batches are refused before upload. - Recovery reconciles decisions. An owner-inserted death the state does not show quarantines with `history`, and cannot be deleted (EVL09). - Commit and decision UPDATE and DELETE are EVL09 even for the owner; the defense-in-depth test disables and restores the trigger explicitly. - Lineage profile: a death is recorded with the archived organism id and reconciled against the archive. - Migrations: clean→v5, v1→v5 and v3→v5 with an existing v1-manifest commit; tampered checksums for v2 through v5 and an unknown v6 are refused. - Mutations (scratch SQL copies; host source restored and rerun green), each caught: removing idempotent retry, outcome finality, the decision-digest check, decision recording, or recovery reconciliation. - Local measurements, including predecessor replay: Release 6.6-8.1 ms per batch; analysis about 20-23 ms; ASan about 19-21 ms. Manifest publish p50 about 0.75-0.86 ms. - Not executed: Docker/Gitea CI, remote object store, process kill, a broker consumer, an injected failure between commit insert and statement end, and TSan. ### M7.5 review fixes - 2026-09-28 - P1 object durability: - `put()` now re-fsyncs the file and the directory before reusing an existing object, on both the found-existing and the lost link-race paths. - Namespace opens always sync the parent directory. - A test-only `ObjectStoreFaults` hook injects directory-sync failures and counts successful syncs. - Tests: a namespace-creation sync failure, then a reopen still failing, then success with exactly 2 syncs. An install sync failure leaves the object visible but unacknowledged, three retries while syncs fail all return io with no extra syncs, then success with +1 sync; every reuse adds a sync. - Publication with 1, 1 and 2 injected failures returns `upload`/io and sends no manifest (head stays 0), then publishes once syncs succeed. - Reverting the reuse sync or the always-sync namespace behavior makes these tests fail. - P1 pre-v5 history: - `pre_v5_guard.sql` (EVL10) runs before 0005 in every upgrade path. 0005 and its checksum are unchanged. - CI builds a real v4 database: v1 genesis, a lease, and a sequence-1 publication through the v4 function. The v5 upgrade is refused with the expected message; history stays 1..4, both commits remain, and no decision table is created. Replacing the guard with a no-op makes that check fail. - A committed death published without any decision (the state an accepted legacy upgrade would produce) recovers as `history`, quarantined and never served. - Reran GCC14 Release (3 runs), clang-tidy analysis (1) and ASan/UBSan (2) PostgreSQL suites, all passing, and the repository format check. The changes are Linux-only persistence code, SQL and tests; the portable targets and Windows are unchanged. ## M7.6 region host - 2026-09-28 - Windows MSVC Release CTest passed 58/58; this change touches only the Linux PostgreSQL CMake section and Linux sources. The repository clang-format 19 check passed. - WSL Linux: GCC14 Release, clang19 analysis (clang-tidy) and clang19 ASan/UBSan builds of `evo-postgres-tests` and `evo-server` passed the full PostgreSQL suite. Final runs: Release 3, analysis 1, ASan 3 across both verification passes. - The first analysis build flagged unchecked optional accesses and ignored release results in the host and server, plus two test issues. These were fixed with explicit local checks rather than suppressions, then rebuilt and rerun in all three configurations. - Host scenarios (real PostgreSQL, scaled scheduling clock, 4 s test lease): - Admission: not_ready before recovery, 64-input cap (full), duplicate and invalid refusals, byte accounting. - Ticks 1–19 are provisional with no acks. Tick 20's death pauses and commits in the same step: 20 acks and one outcome (consumer, organism 11, sequence 1). The next batch flushed by interval at tick 41. - Starvation: debt reached 10 without invented ticks, then catch-up of 8 per step. - Storage outage: the sealed batch waits with nothing acknowledged and debt growing, then commits when storage recovers. - Lease row locked: the commit becomes unknown, the host is not ready and refuses admission, and resolution adopts the receipt after release. - Renewals blocked past the local deadline: fence, all 8 unconfirmed inputs reported `fenced`, then re-acquisition at a newer epoch from the committed head. - Drain (environmental profile): backlog dropped as drained, 6 pending ticks committed, lease released, and a successor acquired immediately at epoch 2. - Unrestorable build and foreign frame quarantine; an invalid configuration is refused. - Process tests (real `evo-server` via posix_spawn, stdin and stdout pipes): - SIGTERM after 80 inputs: exit 0, 80 acks, head 80 at sequence 8, lease released, readiness file removed, max_queued 64. The outcome line followed tick 20's final ack. - SIGKILL during running: every acked tick ≤ the committed head (11/11) and the lease was left held. The successor was ready after 3.94–3.97 s at epoch 2 with committed=11, then drained cleanly. - Mutations (restored and rerun green), each caught: acknowledging at simulation time, not committing a sealed death, reporting ready while resolving, and draining without releasing the lease. - Not executed: Docker/Gitea CI, TSan (the host is single-threaded; libpq is uninstrumented), remote PostgreSQL/TLS, a production 20 s lease kill test, durable client deduplication, and a network gateway. ## M7.7 recovery before readiness - 2026-09-28 - WSL Linux: GCC14 Release, clang19 analysis (clang-tidy, clean on the first build) and clang19 ASan/UBSan builds of `evo-postgres-tests` and `evo-server` passed the full PostgreSQL suite, including the M7.7 recovery tests. Runs: Release 2, analysis 1, ASan 2. The repository format check passed after reordering one fixture include. - Windows was not rerun. This change touches only Linux persistence and host code, SQL, tests and docs; M7.6's Windows run (58/58) covers the portable targets, which are unchanged. - Kill matrix (real SIGKILL via `--crash-at`, inputs 1..40 with a death at tick 20, 5 s flush): | Crash point | Head (seq/tick) | Acked up to | Decisions | Objects | |---|---|---|---|---| | before-transaction:1 | 0/0 | none | 0 | 3 (verified orphans) | | before-upload:2 | 1/20 | 20 | 1 | 3 | | before-transaction:2 | 1/20 | 20 | 1 | 5 (orphans) | | after-commit:2 | 2/40 | 20 (lost acks are the safe direction) | 1 | 5 | | after-ack:2 | 2/40 | 40 | 1 | 5 | The lease stayed held after every kill. Each successor became ready at epoch 2 from the committed head (with tail verification), then drained and released. - Resumed stale owner: the owner was SIGSTOPped for 4.5 s (4 s lease). The successor became ready at epoch 2 with committed=10 and processed ticks 11–20. After SIGCONT the old owner printed `ready 0`, rejected new inputs as `not_ready`, acknowledged nothing beyond tick 10, and exited 0 on SIGTERM without touching the successor's chain. - Damaged heads: a flipped head payload byte and a missing head trace each made `evo-server` exit 4 (quarantined) without ever printing `ready 1`, and the head was unchanged. After repair a successor became ready at epoch 4. - Tail verification (in-process): a missing or corrupt head trace and a missing predecessor payload are `tail`, and recovery succeeds again after repair. A published trace of different inputs over the same range (a host bypass the database cannot detect) is `tail`. - Mutations (restored and rerun green): skipping tail verification made the quarantine test time out because the server became ready. Dropping replay byte-equality failed the forged-trace test (line 262). - Not executed: Docker/Gitea CI, the production 20 s lease, host loss or VM freeze, multi-host network partitions, or verification of links older than the head. ## M7.8 operations endpoints - 2026-09-28 - Windows MSVC Release CTest passed 59/59, including the new portable `ops-contracts`: exposition format, HELP/TYPE per family, the fixed 30-series set, bounded labels, one-hot phase and non-wrapping lag. The exposition is 3485 bytes typically and 3836 at worst-case values (limit 8192). - WSL Linux: the `checks` build set (GCC14 Debug and Release, clang19 analysis, clang19 ASan/UBSan) passed CTest 59/59 each. - The PostgreSQL suites (GCC Release, clang-tidy analysis, ASan/UBSan) passed after fixing the ops test's optional-access and reserve findings. The earlier PostgreSQL analysis runs used a stale binary and are not counted. The repository format check passed after formatting the server. - Process probe tests (real `evo-server`, loopback, ephemeral port): - Serving: `/livez` 200 `live`, `/readyz` 200 `ready`. Metrics showed ready 1, epoch 1, lease remaining above 0, capacities 64/65536 and the running phase. After 30 inputs: committed tick 30, lag 0, 30 acknowledgements, checkpoint age under 60 s. - HTTP bounds: POST 405, unknown path and query string 404, malformed 400, over 4 KiB 431. Eight idle connections do not block probes; a ninth is closed within 500 ms; idle ones close at their deadline. - Database unreachable: `/livez` 200, `/readyz` 503 `not ready: acquiring`, ready 0, store failures above 0, never `ready 1`, exit 0 on SIGTERM. - Stale process (SIGSTOP 4.5 s, then SIGCONT): `/livez` 200, `/readyz` 503, ready 0, fences_total 1, lease remaining 0. The successor answers 200 at epoch 2. - Mutations (restored and rerun green): readiness that returns 200 whenever live was caught. Raising the connection bound to 1000 was not caught at first, because the check did not distinguish refusal from deadline expiry. The test now requires the refusal within 500 ms and catches it. - Image: the Docker engine was not running locally (Docker Desktop stopped), so the `server-runtime` build and `tools/ci/server-image-smoke.sh` have not executed. A filesystem emulation (binary plus the pinned libpq, `env -i`) showed usage exit 2 with no settings and all libraries resolved. It also found and fixed a bug: without arguments the server had reached object-store opening instead of refusing with usage. The binary keeps a build-tree RUNPATH, which is harmless in the image. - The manifest example parses (Deployment and NetworkPolicy, three probes) and the workflow YAML parses; `bash -n` passed for the smoke script. - Not executed: the container build and smoke, the Gitea job, cluster apply, Prometheus scraping, and TSan. ## M7.9a region clones and retained history - 2026-09-29 - Windows MSVC Release CTest passed 59/59. `lineage-region-contracts` now covers rebinding: only the new identity restores, continuation matches, and rebinding back is byte-exact. `region-checkpoint-contracts` covers the clone-genesis manifest rules. - WSL Linux `checks` set (GCC14 Debug and Release, clang19 analysis, clang19 ASan/UBSan) passed CTest 59/59 each. The format check passed. - The PostgreSQL suites passed in GCC Release, clang-tidy analysis and ASan/UBSan. These runs used a second database, `evo_clone`, with its own runtime group and login. clang-tidy first flagged branch-clone in the tool's option parsing and optional access in the new tests; both were fixed, then the suites were rebuilt and rerun. - Harness additions: - A populated v6 database (a v2 genesis) upgrades in place to v7. The replaced head constraint is `region_heads_published_tick`, and the v7 parser reads the stored genesis. - Upgrade paths now end at 1..7. - Version and checksum drift checks now include v7. - Clone tests (real `evo-server` and `evo-world-clone` processes): - Trajectory: world 7 was run to tick 30, with a death at tick 20, then cloned to world 8 in `evo_clone`. The clone recovered under the clone runtime at tick 30, with the inherited death and retained ancestry, and the audit found one clone link naming the source cut. Both worlds then ran inputs 31..90; after rebinding the clone to world 7, the snapshots were byte-identical. - Isolation: - A same-world target was refused as `identity`. - A world that already holds an original region was refused (22023). - A forged origin was refused (22023). - The runtime role cannot provision a clone (42501). - A clone world refuses an original region. - Origins are immutable (EVL09). - The source session is read-only (25006, even through SECURITY DEFINER). - A clone lease publishing a successor to the source is fenced. - The clone runtime login cannot reach the source's functions (42501). - The source head and decisions were unchanged afterwards. - Failure: a SIGKILL before the target transaction left the source unchanged, the target unprovisioned with one orphan object, and a target server that quarantined (exit 4) without becoming ready. The tool refused a same database or same user (exit 2) and a same world (exit 4). The retry succeeded and reused the same object. A source with a damaged head payload was refused (exit 3), and its target stayed untouched. - Retention: an owner was SIGKILLed after acknowledging tick 100, and its successor continued to tick 200. The audit verified every link, and the tool printed the same result. A lower `max_commits` returned `bounds`. Removing the first link's trace made the audit report `tail` at sequence 1 while head recovery still succeeded; restoring the trace made the audit pass again. - Environmental profile: a clone inherited the tick-20 death. Moving that durable row to tick 19 (triggers disabled as break-glass) made recovery report `history` and the audit report `history` at sequence 0. Moving it back made recovery pass. - Mutations (each restored and rebuilt afterwards). Each was caught by its intended check: - dropping the isolated-world refusal; - dropping the origin check; - a read-write source session; - skipping the inherited-outcome digest; - skipping the audit's per-link tail verification. The first attempt at the inherited-outcome mutation did not compile, so its stale-binary run was discarded and the mutation was rerun. - Not executed: clones across separate PostgreSQL clusters or hosts, Docker, the Gitea CI, and cluster runs. ## M7.9b upgrade barrier and durability qualification - 2026-09-29 - Every M7.9b change is in the Linux PostgreSQL build or in docs. Windows was not rerun; its 59/59 from M7.9a still covers the portable code, which is unchanged. - WSL Linux `checks` set (GCC14 Debug and Release, clang19 analysis, clang19 ASan/UBSan) passed CTest 59/59 each. The format check passed. - The PostgreSQL suites passed in GCC Release, clang-tidy analysis and ASan/UBSan. After the mutation run, one host test was corrected: `unrestorable_head_quarantines` now retains its build, so the quarantine it checks again comes from recovery rather than acquisition. Release and analysis were rebuilt and rerun green after that change. The ASan build compiled with it, but its full run predates it. - Harness: upgrade paths now end at 1..8. The populated v6 database upgrades to v8. Version and checksum drift checks include v8. - Migration and barrier test (database `evo_online`, created at v7 from the checked-in files): - A pre-v8 writer with a build-less lease published ticks 1..20 (with the death). - An `apply.sql` run with an invalid v8 checksum failed. It left history 1..7, no `retired_at` column and no four-argument acquire. The writer renewed and published ticks 21..40. - The real migration then reached v8 while the writer held its lease, and the writer published ticks 41..60. - Barrier refusals: the runtime cannot call it (42501), and retiring the last current build is refused (22023). - After the barrier (1 lease fenced), the old writer's publication and renewal were fenced. Build-less acquisition returned EVL06, and acquisition with b1 returned unsupported. - A b2 lease publishing a link that names b1 was refused as unsupported. - A b2 `evo-server` became ready at epoch 3 from committed tick 60 and acknowledged through tick 90. Its final head is built by b2. - The audit passes with both builds retained, and reports unsupported at sequence 0 with only b2. - A b1 `evo-server` quarantined (exit 4) without becoming ready, and the head was unchanged. - Qualification: see engineering/DURABILITY_QUALIFICATION.md. SIGKILL to ready took 19.5–19.6 s under the production lease in all three builds (the 60 s target is asserted). Acknowledgement latency p50 was about 549 ms and p99 about 1048 ms. No acknowledged input was lost, and one durable death was recorded across five owners. - Mutations (each restored and rebuilt). Each was caught: - no retired-build trigger; - no build check in four-argument acquisition; - no barrier check in build-less acquisition; - a barrier that does not fence holders; - a host that retries an unsupported acquisition instead of quarantining. The migration test caught this one after the host-test correction. - Not executed: Docker, the Gitea CI, cluster runs, a separate database host, and host or storage loss (M8). ## M7.6–M7.9 review fixes (schema v9) - 2026-09-29 Review `.cache/reviews/M7_6-M7_9_REVIEW.md` found three issues. All three are fixed: - **[P1] Build retirement could race acquisition.** Schema v9 applies one upgrade-lock order across the barrier, acquisitions, lease checks, provisioning and the retired-build trigger. - **[P2] Clone-world classification could race.** Provisioning now takes a per-world lock and checks classification after it. - **[P2] The operations listener accepted without bound.** Each `serve()` now makes at most 4 accept attempts. Evidence: - WSL Linux `checks` set (Debug, Release, analysis, ASan/UBSan): CTest 59/59 each. The format check passed. - PostgreSQL ASan/UBSan: full suite passed. Analysis and Release were rerun green after fixing two clang-tidy findings in the new tests. Upgrade paths now end at 1..9. - Race tests (database `evo_race`): each holds a transaction open, confirms the contender is blocked on a lock via `pg_stat_activity`, then commits. - A build-less acquisition queued behind a barrier is refused (EVL06). - A build-aware acquisition of the build being retired is refused, and the region stays unheld. - The next build acquires. - Racing barriers for the last two current builds: one returns 22023 and one build stays current. - Different-source clones into one world, and an original region racing a clone: the second is refused (22023). - Same-source clones into different regions both succeed. - The final origins are exactly `2/1<10, 4/1<10, 4/2<10`. - Accept budget: - With 16 queued connections, successive `serve()` calls give 4 open, then 8 open with 0 refused, then 8 open with 4 refused. - Refusals never exceed 4 per call under replenished connections. - The first accepted probe got 200. - A real server acknowledged 60 ticks under continuous connect/close churn without losing readiness. - Mutations, each reverting one fix (restored and rebuilt). Each was caught: - an unlocked build-aware acquire; - an unlocked legacy acquire; - an unlocked barrier; - no per-world lock; - an accept budget of 1000. - Qualification was unchanged: SIGKILL to ready took 19.55–19.60 s. - Windows was not rerun. All changes are Linux PostgreSQL, server or doc files. ## M8.1a inventory preparation - 2026-09-29 - No cluster access was available: there is no kubeconfig on the workstation. Nothing in the cluster was read or changed, and the `aevolution-db` Secret was not accessed. Only the key names the maintainer supplied are recorded. - `tools/inventory/collect-cluster.sh` passed `bash -n`. It has not been run against a cluster. It only reads, and it lists Secrets through the server-side table, so no data is fetched. - `deploy/kubernetes/inventory/disk-probe.yaml.example` parses as a PVC, NetworkPolicy and Job. Its script was run locally in WSL2 on ext4 as a baseline: - 4 KiB O_DSYNC writes: mean 1169 µs; - 40 KiB object publication: mean 4646 µs, max 7983 µs; - 256 MiB fdatasync: 365 ms. It has not been applied in any cluster. - The qualification now records the server's resource profile from /proc. Over three owners in Release: peak RSS 9,940 KiB, and 60 ms CPU over 16.3 s of serving. The full PostgreSQL Release suite passed with it. The analysis build compiled clean, and the format check passed. ## M8.1b cluster inventory - 2026-09-29 - The maintainer ran `tools/inventory/collect-cluster.sh`. It made read requests only, and listed Secrets as name, type and key count. The output is in `C:\tmp\cluster` on the workstation and is not committed. The results are summarized in docs/infrastructure/INVENTORY.md: - RKE2 v1.32.5 with one untainted control plane (6 vCPU / 11.7 GiB) and three workers (8 vCPU / 31.3 GiB). - No kubelet reservations, quotas or LimitRanges. - Storage is `local-path` only (reclaim Delete, no CSI, no snapshots). - Canal/Calico, ingress-nginx, MetalLB and cert-manager with Let's Encrypt. - `aevolution-dev` has no automated sync. - No PostgreSQL 18.6 in the cluster (Gitea runs 17.6). - The collector ran as cluster-admin. A read-only identity is an M8.2 item. - `deploy/kubernetes/inventory/disk-probe-local-path.yaml` parses as one NetworkPolicy and three PVC/Job pairs, pinned to worker-1..3. It is outside every Argo path and has **not yet been applied**, because this workstation has no kubeconfig. The maintainer approved running it. Its results go in INVENTORY.md. ## M8.1c storage probe and corrections - 2026-09-29 - The maintainer applied `deploy/kubernetes/inventory/disk-probe-local-path.yaml` by hand on the cluster, and all three Jobs completed. The resources were then deleted. - worker-1: 1906 µs dsync, 28.7/60.6 ms object publish, 1003 ms for 256 MiB. - worker-2: 2511 µs, 36.0/73.4 ms, 2122 ms. - worker-3: 2239 µs, 32.1/61.0 ms, 2339 ms. Its root filesystem is 87 % full. Every `local-path` volume is on the node's root LVM ext4 volume. The figures are provisional until the planned RAID change. - Corrections from the maintainer: - Host RAM was increased by about 500 GB, so the earlier "about 20 GiB left" estimate is withdrawn. - AEvolution's PostgreSQL is a separate VM outside Kubernetes, reached through `aevolution-db`. - Collection is manual, with no automation planned. - No credential values were read. The 18.6 version, role and TLS requirements are enforced by the adapter and migrations when M8.3 connects. ## M8.2 environment isolation - 2026-09-29 - `tools/ci/deploy-policy-check.py` (WSL, Python 3 with PyYAML): 35 objects in 27 files, 0 failures. - Nine mutations were each caught, then restored: - World0 auto-sync; - the World0 cascade finalizer; - the policy set to failurePolicy Ignore; - the policy no longer covering Secrets; - an egress hole in default-deny; - the World0 protected label removed; - the cleanup tool accepting world0 (rc 127, it reached kubectl); - service-account token automount; - a wildcard stage destination. - `kubectl kustomize` (client v1.31.4) renders the dev, stage and World0 platform overlays (9 objects each), and still renders the live `deploy/kubernetes/dev` path unchanged. - `bash -n` passes for both ops scripts. - The CI `deploy` suite (a Docker `ci-deploy` stage) has not run yet; Docker is not running locally. - Not executed: applying anything to the cluster, the admission policy's CEL compilation (it needs an API server; the runbook validates it with a server dry run first), and `tools/ops/verify-isolation.sh`. ## M8.2 live verification - 2026-09-29 The maintainer applied the dev, stage and World0 platform overlays, the World0 admission policy and the stage and World0 AppProjects, then ran `tools/ops/verify-isolation.sh` against the cluster. The output is kept locally in `k8s-script-results.md`, which is gitignored. - **Guardrails:** 24 PASS. All three namespaces have their labels (World0 is protected), quota, limit range, default-deny and DNS policies, and three service accounts. - **RBAC negatives:** 144 PASS. None of the nine environment service accounts can get or list secrets, create pods, delete PVCs or create rolebindings in any of the three namespaces, and none can delete namespaces. - **Admission:** 3 PASS, 2 SKIP. The policy is bound. Server dry runs deleting the World0 namespace and a World0 service account were both denied, naming the break-glass group. The secret and PVC cases were skipped because none exist in World0 yet. - **Cleanup:** 4 PASS. The tool refused `world0`, `evolution-world0`, `World0` and the empty name. - **Projects:** 3 FAIL, all a script defect. The project jsonpath concatenated the destinations with the cluster whitelist, which prints `[]` when empty. The destinations themselves were exactly `evolution-`, with an empty whitelist. The script now checks destinations and cluster kinds separately and accepts `[]`. The corrected script has not been re-run on the cluster. - **WARN:** the `default` AppProject allows every namespace. The maintainer accepted this (docs/BACKLOG.md). ## M8.3 dev/stage stores - 2026-09-29 - WSL Linux `checks` set: CTest 59/59 in each configuration. The format check passed. - PostgreSQL suites: Release and ASan/UBSan passed with the new `region_store_tests`. Analysis passed after one clang-tidy fix (an int multiplication widened in the MiB report). - Store tests: - An unreachable reserve refuses new objects with `full`, leaving no files. An identical existing object is still reused. - A lineage batch through a full store fails as `upload`/`full`, and the head is unchanged. - RLIMIT_FSIZE makes a real write fail with `io`, leaving no object or temporary. - `check-store`: - its first run creates the probe and its second verifies it; - a missing root exits 4 without creating it; - a full volume exits 4; - an owner login exits 3 (tables READABLE); - the runtime login reports `version=180006 ... ssl=false` (local socket), and `tables=denied functions=reachable`. - An `evo-server` whose reserve cannot be met simulated but acknowledged nothing. Its drain exited 3, and the head was unchanged. - Mutations (restored and rebuilt), each caught: - removing the reserve check; - `check-store` always succeeding. - `tools/ci/deploy-policy-check.py`: 41 objects, 0 failures. Four new-rule mutations were caught: - a Delete class; - a platform claim on `local-path`; - a `PGPASSWORD` key reference; - a whole-Secret `envFrom`. - Kustomize renders the dev and stage overlays with the `aevolution-objects` claim; World0 has none. - The server image now contains `evo-world-clone`, and its smoke script checks the tool's usage exit. It has not been built locally, because Docker is not running. - Not executed: anything in the cluster, the store Jobs, retention, rebind and rotation evidence, and the image build. ## M8.3 service-file connections - 2026-09-29 - The maintainer's dev Secrets have the keys `ca.crt`, `pg_service.conf` (section `[evolution]`) and `pgpass`, with no `user` key. The values were pasted into the conversation, so both passwords must be rotated. That rotation is also the M8.3 credential-rotation evidence step. The values are not recorded anywhere in the repository. - `read_pg_service` and `--pg-service` were added to `evo-server` and `evo-world-clone`. - Parser tests: a valid file with another section and CRLF lines parses. The parser refuses: - `password`, `passfile` and `options` keys; - `sslmode=require`; - a repeated key or a repeated section; - a non-numeric timeout; - malformed lines; - a missing section; - a file over 4 KiB; - a missing file. `sslmode=disable` is accepted only for a local socket. - `check-store --pg-service` against the local cluster verified the probe and the privilege boundary. - The store Jobs now mount each login Secret whole (service file, password file, CA) and no longer read `aevolution-db`. The migrate Job's `PGSERVICE` is now `evolution`; the previous `evolution-migrator` did not match the maintainer's file. - PostgreSQL Release and ASan/UBSan passed. The analysis build passed after one loop copy was fixed. Deploy policy: 0 failures. ## M8.3 Argo delivery - 2026-09-29 - The platform layer is now `deploy/kubernetes/platform/cluster`, delivered by the `aevolution-platform` Application. It renders 29 objects, all marked `Prune=false,Delete=false`: 3 namespaces, 3 quotas, 3 limit ranges, 6 network policies, 9 service accounts, 2 claims, the storage class, the policy and its binding. - The store Jobs are kustomize components used as Argo hooks. The dev overlay renders into `evolution-dev` with PreSync and PostSync hooks; its digests and role are still markers. - `deploy-policy-check.py`: 43 objects in 41 files, 0 failures. Five new mutations were each caught: - platform prune enabled; - a missing Delete guard; - an unfinished stores overlay included in the live dev path; - an extra cluster kind in the platform project; - the admission policy no longer covering the platform app. The unfinished-path rule first missed the live dev Application, which exists here only as an `.example`. It now covers every Application whose path is resolved. - The digests the maintainer pasted are local image IDs from the build step, not registry digests. The registry digest is printed by the Publish step. - Not executed: bootstrapping the platform Application, or any Argo sync. ## M8.4 region host - 2026-09-29 - Windows MSVC Release CTest 59/59, including the new opening code. `lineage-region-contracts` proves `development_opening(7)` is byte-identical to the fixture, and that world 100 differs only by identity. - WSL Linux `checks` set: 59/59 in each configuration. The format check passed. - PostgreSQL suites: Release, analysis and ASan/UBSan passed. Analysis passed after one optional-access fix in `provision`. - Provisioning test: - A runtime login cannot provision. - The owner provisions `world=7 region=86 sequence=0 tick=0`, and a rerun reports `already-provisioned`. - A server then became ready and acknowledged ticks 1–5, after which the tool reported `sequence=1 tick=5` and left the region untouched. - Mutation: removing the already-provisioned early return was caught. - `deploy-policy-check.py`: 50 objects, 0 failures. Four new mutations were each caught: - a build identity differing from the image digest; - a RollingUpdate strategy; - a CPU limit; - a grace period shorter than the drain. The checker first misread overlay patches as whole Deployments; it now checks only the base. - Kustomize renders dev and stage in order: egress policy (−2), migration hook (−1), provisioning hook (0), Deployment and Service (1), then the store check (PostSync). - `region-drill.sh` passed `bash -n`, and refuses World0 before kubectl (also enforced by the policy check). - Not executed: the in-cluster region sync and the drill. ## M8.5 observability - 2026-09-30 - `promtool` 3.13.3 and `amtool` 0.34.1 came from the official release tarballs, with SHA-256 verified against the published sums: `b349c732…` and `265b9d1e…`. - The Prometheus configuration syntax is valid, and all 16 rules are valid. - The alert injection tests passed, as did the Alertmanager `check-config`. - Rule mutations: five were tried, and three were caught at first. - **NotReady firing after 15 s:** missed, because the forced-deletion test only evaluated after recovery. The test now also checks during the dip. - **ObjectsFull weakened to half the reserve:** missed, because the injected free space was below both thresholds. The test now uses 900 MB. - After these fixes all five were caught: the lease threshold, NotReady too eager, debt counted without inputs, a weakened ObjectsFull, and `refused` drops counted. - Windows MSVC CTest 59/59, including the `ops-contracts` update to 32 series. - WSL Linux `checks` set: 59/59 in each configuration. The format check passed. - PostgreSQL suites: Release, analysis and ASan/UBSan passed. The ops process test checks the reserve gauge (1 GiB) and that free space is nonzero. - `deploy-policy-check.py`: 67 objects, 0 failures. New rules: - monitoring images must be digest-pinned; - monitoring pods mount no token; - no RBAC objects are allowed; - the monitoring project is scoped. - Kustomize renders the platform bundle (four namespaces), the monitoring app (2 Deployments, 2 ConfigMaps, 2 Services, 2 policies, 1 claim), and dev and stage with the scrape policy. - The CI `ci-deploy` stage now copies `promtool` and `amtool` from the pinned images and runs `tools/ci/monitoring-check.sh`. It has not run locally, because Docker is not running. - Not executed: anything in the cluster (monitoring sync, target health, the `EvoRegionDown` injection), alert delivery (no receiver), and the node log rotation check. ## M8.4 and M8.5 in-cluster results - 2026-09-30 - `tools/ops/region-drill.sh dev`, run by the maintainer (idle region, world 100): - start: epoch 3, committed tick 0; - rollout restart: the replacement was Ready in **3010 ms**, at epoch 4 with committed tick 0 (Recreate drain released the lease); - forced deletion: the replacement was Ready in **19268 ms**, at epoch 5 with committed tick 0 (waiting out the 20 s lease); - PASS. - M8.5: the maintainer reports the new server digest pinned and the monitoring project, platform, monitoring app and dev/stage applications synced. Target health and the `EvoRegionDown` injection results were not recorded here. - Image upgrade to `edb39f…`: completed with `REGION_RETAINED=4af72099…`, so the existing dev and stage heads, written by the earlier build, stay recoverable after the upgrade. ## M8.6 synthetic load and fault drills - 2026-09-30 - `region_load_tests` (real PostgreSQL and real `evo-server`, fast lease): - A synthetic owner acknowledged contiguously from tick 1 past tick 45, with deterministic `SYN1` IDs. The consumer's death was emitted as an outcome. - After a SIGKILL mid-stream, every acknowledgement was at or below the committed head, and there was exactly one durable decision. - The successor started at epoch 2 and acknowledged exactly committed + 1 onward, with no repeated death. - With synthetic inputs enabled, a line typed on stdin was ignored. - `lineage-region-contracts`: `development_input(t)` equals the fixture's `region_input(t, true)` for ticks 1–200. - Mutation: resuming the driver at committed + 2 was caught by the contiguity check. - Windows MSVC CTest 59/59. WSL Linux `checks` set: 59/59 in each configuration. PostgreSQL suites passed in Release, analysis and ASan/UBSan. The format check passed. - `deploy-policy-check.py`: 67 objects, 0 failures. New rules: `REGION_INPUTS` must be empty in Git, and `fault-drill.sh` must refuse World0 before kubectl. - `fault-drill.sh` passed `bash -n`. It refuses `world0` and unknown scenarios (exit 2) without calling kubectl. - Not executed: the in-cluster drill (kills, full, empty, db-outage). ### M8.6 first in-cluster drill (dev, run by the maintainer) - 2026-09-30 `fault-drill.sh dev all`, then `fault-drill.sh dev db-outage`: - **kills: PASS.** RTO 20 147, 19 777 and 20 222 ms (lease-bound, as ADR-0073 expects). The dead pods' highest acknowledgements (209, 419, 629) equalled the heads their successors recovered: no acknowledgement was lost. - **full: PASS, with a finding.** No acknowledgement while full, and recovery from the committed head afterwards. But `store_failures` reached 4 247 in about 30 s: the host retried a refused publication on every step. - **empty: PASS, with an evidence gap.** No pod became Ready, and restoring the volume recovered committed 894, past the last acknowledgement (888). The script found no `phase quarantined` line, because it read only the previous container's log. - **db-outage: FAIL, not yet diagnosed.** The host stayed Ready for the whole 10-minute window. Nothing shows that the database was actually unreachable from the pod's node. The prompt did not name the node or the rule to apply, so the block may have targeted another address. Fixes (this segment): - `RegionHost` backs off commit retries after a store failure: 100 ms, doubling to a 2 s cap, and reset by the next confirmed commit. `region_host_tests` now expects exactly 2 attempts in the first 200 ms and 5 in 2 s of a store outage, and a commit within 23 steps after the store heals. Mutation: removing the backoff gate was caught. - `fault-drill.sh` empty: reports the restart count and last exit code (4 means quarantined), keeps the current and previous logs, and prints their tails. - `fault-drill.sh` db-outage: prints the pod's node, the node's InternalIP, and the exact `iptables` insert and delete rules to run on the database VM. - Checks run: the format check; WSL `checks` 59/59 in debug, release, analysis and ASan; the PostgreSQL suites in analysis and ASan/UBSan; the mutation. Windows MSVC CTest 59/59 (the server is not part of the Windows build). `fault-drill.sh` passed `bash -n`. - Pending: a new image, then re-running the full, empty and db-outage scenarios. ## M8.7 backup and restore - 2026-09-30 - `tools/ci/backup-check.sh` (inside `postgres-check.sh`; real PostgreSQL 18.6, a real `evo-server` under synthetic load) passed in the Release, analysis and ASan/UBSan PostgreSQL builds: - An online backup taken while the server committed recorded head tick 60, at or past every acknowledgement before it (60). The source then moved on to tick 101. - `verify-backup.sh --isolate 301` on a second, throwaway cluster, as fresh roles: the restore audited 13 commits to tick 60 and matched the MANIFEST. The clone into world 301 resumed at `epoch=1 committed=60`, acknowledged to tick 82, and drained with exit 0. - Refused bundles, each leaving no schema and no objects behind: - corrupt object, unlisted file, damaged dump: exit 4 at the checksum step; - missing payload object with consistent checksums: exit 3, `audit failed missing_payload sequence=0`; - MANIFEST head changed: exit 3, heads differ. - A second restore into a database that already holds a world was refused (exit 4), and the first restore was left unchanged. - The MANIFEST names no credentials. - Mutations, each caught by `backup-check.sh`: - restore without the history audit: the missing object was accepted (exit 0); - a failed restore that keeps its files: restored objects were left behind; - `pg_dump` outside the exported snapshot (2 s later): the restored heads differed from the MANIFEST, and verification failed. - The PostgreSQL migration, rollback and permission suites passed in all three builds. `deploy-policy-check.py`: 67 objects, 0 failures. `cluster-backup.sh` refuses World0 before kubectl (policy rule). - `bash -n` passed on every new script. shellcheck is not installed in WSL, so it did not run. - Not executed: - the postgres-tools image build with `pg_dump` (CI builds it on push); - `cluster-backup.sh` against dev or stage; - any restore of in-cluster data. - The permanent destination, encryption, schedule and WAL archiving are not implemented; they are pending the maintainer's choice of destination. ## M8.8 World0 gate and host-loss rehearsal - 2026-09-30 - `tools/ci/dr-check.sh` (inside `postgres-check.sh`; real PostgreSQL 18.6 and real `evo-server` processes) passed in the Release, analysis and ASan/UBSan PostgreSQL builds. The Release run: - The old host served world 400 past the tick-20 death. - An online backup cut at tick 40, and the old host went on acknowledging, to tick 110. - An in-place restore into a replacement database, with the old host still running, audited 9 commits and printed `REWIND ... restored at tick 40`. It left no lease held and passed the runtime rights audit. - The new host resumed at `phase running epoch=2 committed=40`, and its first acknowledgement was tick 41. - `fence-database.sh` retired build b1…, leaving `current 0` and `held 0`, and printed the final head (`final 400 1 22 110 1`). The still-running old host dropped its queued inputs as `fenced` and exited 4 (quarantined). The old head stayed at 110. - A later host on the fenced database logged `phase quarantined` and exited 4, never ready and with no acknowledgement. - The restored world's audit passed (16 commits to tick 73, one outcome). There was exactly one durable decision, and the new host printed no `outcome 20`. - Measured rewind: 70 acknowledged ticks (110 − 40). - The ASan run measured 115 and 75. - Mutations, each caught by `dr-check.sh`: - leases not fenced on restore: "a restored lease is still held"; - fence without the barrier: "fence evidence"; - in-place restore without grants: the runtime rights audit failed, and the restore was removed. - Deploy policy negatives, each rejected: a Job in the World0 path; the World0 Application with a resolved path; a `region/world0` overlay pinning a digest that is not stage's. The unmodified tree: 67 objects, 0 failures. - Found and fixed during validation: `dr-check.sh`'s EXIT trap ran `kill -9` on exited processes under `set -e`, which made the script exit 1 after passing (the kill now ends in `|| true`). - The backup check still passes with grants kept in the dump. - Not executed: - any in-cluster host-loss restore or fence; - a second failure domain, which does not exist; - any World0 deployment or promotion, which is blocked by design. ## M8.9 upgrade rehearsal and node plan - 2026-09-30 - `region_upgrade_tests` (real evo-server and evo-world-clone processes) passed in the Release, analysis and ASan/UBSan PostgreSQL builds: - Current build b1 and candidate b2 ran on clones of one cut, at 20× acceleration, from tick 30 to tick 150: 120 ticks, 6 s of region time. Wall times were 306/307 ms (Release), 322/323 ms (analysis) and 299/299 ms (ASan). - `compare` passed: `compared tick=150 outcomes=1`. - A temperature-shifted input stream gave `compare differs state` (exit 6). - A clone stopped at tick 100 gave `compare differs ticks` (exit 6). - Comparing a world with itself, and `--accelerate` or `--synthetic-until` without the driver, were usage errors (exit 2). - `tools/ci/upgrade-check.sh` passed in all three builds: - A failing migration (migration lock, `ALTER TABLE region_commits`, locks held 3 s, then an error) left schema v9 and no new column. b1 went on acknowledging, and the real migrate was a no-op. - b2 waited while b1 held the lease. `upgrade_barrier(b1)` fenced one lease, and b1 exited 4. - b2 resumed at `epoch=2 committed=135`, at b1's last acknowledgement (135), and continued with tick 136. The ASan run: 137. - A late b1 host exited 4 without becoming ready. - The history audit across both builds passed: 24 commits to tick 167. - Mutations, each caught: - `compare` without the state comparison: upgrade test line 201 (the diverged world passed); - `--synthetic-until` ignored: line 165; - `--accelerate` as a no-op: line 184 (over 4 s). - The WSL `checks` set: 59/59 in debug, release, analysis and ASan. clang-tidy (analysis builds) and the format check were clean. - Deploy policy: 67 objects, 0 failures. Negatives, each rejected: an objects-volume pod without the stores selector; a required compute affinity; `--accelerate` in the region Deployment. `upgrade-barrier.sh` and `scheduling-check.sh` refuse World0 before kubectl. - Found during validation: genesis seed 0xF1 collided with a checkpoint-store test (fixture provisioning failed), and was replaced by the unused 0xD7. clang-tidy flagged duplicated option branches, which were merged. - Not executed: - `upgrade-barrier.sh` or `scheduling-check.sh` against dev or stage; - scheduling onto a second labelled node; - the Windows MSVC build (no Windows target changed; the server and PostgreSQL code are Linux-only). ## M8.1–M8.9 review fixes - 2026-09-30 Review: `.cache/reviews/M8_REVIEW_680e7e5-5b482ad.md` (one P1, five P2). - **P1 restore ownership.** `backup-check.sh` passed in the Release, analysis and ASan/UBSan PostgreSQL builds, including three new cases: - A schema created after the checks but before `pg_restore`: exit 4 ("pg_restore failed; the database was not changed"). The competing table survived, and only this restore's own objects directory was removed. - A second concurrent restore of the same database: exit 4 ("another restore holds this database"). It left no directory, and the first restore was verified. - While the first restore held the database, a lease acquisition there ended in `lock timeout`. An occupied objects path was refused and left untouched. - The reviewer's `restore-race.sh` now ends with `remaining_evolution_schemas=1` (`schema=no, objects=yes`). - **P2 barrier Ready-pod selection.** `tools/ops/lib/pods.sh` uses a plain jsonpath and needs exactly one Ready pod that is not being deleted. `ops-lib-check.sh` passed its fixtures: one pod, not Ready, being deleted, no condition, Ready beside a deleting pod, two Ready pods, and no pods. Not run: the jsonpath against a live API server (no kubectl or Go in this environment). - **P2 barrier Secret access.** The generated pod has `fsGroup: 10001`. The deploy policy check now renders the backup and barrier pods with `--print-manifest` and checks: non-root 10001 with fsGroup 10001, no token, read-only root, no escalation, Secret files 0440, and egress admission of the component. Not run: a disposable pod reading the Secret in the cluster. - **P2 World0 claimRef.** A new admission validation denies removing a World0 volume's claim reference, or changing its namespace or name, without break-glass. The policy check requires the rule, and `verify-isolation.sh` dry-runs the removal when a World0 PV exists. Not run: no admission test cluster here, and no World0 PV exists. - **P2 CI change selection.** `ci-paths.sh` compares against the event's base (the push's `before`, or the PR base, fetched if missing). It runs on manual dispatch, local runs and any uncertainty, and the path lists now include the check scripts. `ci-paths-check.sh` passed 11 fixtures, and the deploy suite runs it first. The reviewer's `ci-range.sh` now runs in both cases. Not run: a real Gitea push, so the event-context mapping is unverified. - **P2 drill verdicts.** Every kill RTO is asserted against `RTO_BUDGET_MS` (60 000). The empty scenario needs positive quarantine evidence; INCONCLUSIVE and other exits fail. Acknowledgements are read from the dead or drained owner's finalized log. The fixtures passed. Not run: the drill itself. - Mutations, each caught: - dropping a schema that was not installed: `backup-check.sh` failed; - removing `fsGroup`: the policy check failed; - accepting several Ready pods, or treating never-ran as PASS: the `ops-lib-check.sh` fixtures failed; - falling back to `HEAD^` when there is no base: the `ci-paths-check.sh` fixtures failed. - The host-loss and upgrade rehearsals, and the PostgreSQL migration and permission suites, still pass in all three builds. The deploy policy check: 67 objects, 0 failures. - ROADMAP corrected: M8-dev/stage is implemented and locally qualified, but **not passed** until the live gates listed there are run. ## Review 3a34ae3 follow-up: durable restore gate - 2026-10-01 Review: `.cache/reviews/REVIEW_3a34ae3.md`. P1: losing the auxiliary claim session released authority before verification. P2: a nonzero `pg_restore` exit was taken as proof of rollback. - `restore-world.sh` no longer relies on an auxiliary lock session. It works in three steps, as the ADR-0074 amendment describes: - an install transaction holds the dump, a claim row with the invocation's nonce, fenced leases and retired builds; - verification follows; - a nonce-checked publish transaction re-enables exactly the held builds. Ambiguous outcomes are resolved from the claim row. An unresolvable one is OUTCOME UNKNOWN (exit 5): the target stays unservable, and `--abandon NONCE --objects DIR` resolves it later. - `backup-check.sh` passed in the Release, analysis and ASan/UBSan PostgreSQL builds, with these cases: - a competing schema before install: the rollback was confirmed and the competitor's table survived; - two concurrent restores: the first installer was verified and published; the second rolled back, confirmed, and left the winner intact; - after install, `acquire_region_lease` was refused ("build not current") both before and after `pg_ctl restart` mid-restore; the restore then verified, and one current build was restored; - a lost install acknowledgement: "install outcome resolved: committed", then verified; - an unreachable resolution: exit 5, both schemas and the objects kept, acquisition refused, `--abandon` with a wrong nonce removed nothing, the right nonce removed everything, and a retry restore succeeded; - an occupied objects path: refused and untouched; - damaged bundles: refused, with no `evolution` or `evolution_restore` left. - The reviewer's claim-loss reproduction, adapted to the renamed hook (`after-install`), finds no lock to terminate. The runtime acquisition inside it failed with `build not current` (exit 1), and the restore then published. - `dr-check.sh` (in-place restore) and `upgrade-check.sh` passed in all three builds. - Mutations: - install without retiring builds: caught ("authority was available before publication"); - resolution ignoring a committed claim: caught (exit 5 instead of verified); - cleanup ignoring the claim's nonce: NOT exercised (the edit pattern failed to apply). The abandon path also checks the nonce first, so that defense is two layers deep and only the outer layer is tested. - Not run: a real network partition around COMMIT. The lost acknowledgement is an injected test mode (`EVO_RESTORE_TEST_INSTALL_ACK`). ## M9.1 scoped native dependency probe — 2026-10-01 Decision: ADR-0077. SDL 3.4.16 shared window/events/2D renderer, explicitly prepared from the official archive with SHA-256 validation. No simulation API, world format, server image or deployed workload changed. Executed: - Windows x64 MSVC 19.44: fresh `client-probe` configure/build and 2/2 labeled CTests passed. Native standalone probes reported `video=windows` with both `renderer=direct3d11` (automatic) and explicitly requested `renderer=vulkan`; synthetic key delivery and rectangle/background pixel readback passed. Developer environment required explicit compiler and Windows SDK tool paths. - WSL Ubuntu, GCC 14 Release: configured the same preset in `build/client-probe-linux` with `SDL_X11=ON`, `SDL_WAYLAND=OFF`; build and 2/2 client CTests passed. `xvfb-run -a env SDL_VIDEO_DRIVER=x11 ./build/client-probe-linux/evo-client-probe --renderer software` passed. X11 development dependencies are reproduced in Docker's `ci-client` stage. - clang-tidy 19 standalone against `experiments/client/main.cpp`, C++23 and the prepared SDL include directory: no owned-code diagnostics. Initial use of the GCC compilation database failed on GCC module options; rerun used explicit Clang arguments. Repository `format-check` passed. - Clang 19 ASan/UBSan build of the owned probe, linked to the Release SDL shared library: dummy video/software renderer passed. SDL itself was not instrumented. **Additional X11 sanitizer run failed LeakSanitizer:** 50,016 bytes in 912 allocations remained at exit; resolved SDL call sites included `X11_InitKeyboard` and `X11_GetGlobalContentScale`, with underlying unloaded library frames unresolved. This is not a proven application leak or a clean native sanitizer result. Do not suppress or declare it fixed. M9.2 must reproduce with symbolized native libraries and establish repeated window-lifecycle memory behavior before desktop qualification. Diagnostic rerun with `LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libX11.so.6` passed with leak detection enabled. Keeping libX11 loaded changes the result, suggesting library unload/static allocation reachability; it does not establish that repeated native lifecycles are leak-free. No suppression was added. - Headless Release, client disabled: configured/built `evo-sim`; seed 123456, eight entities, 1,000 ticks and `--verify-replay` passed, hash `d61ad5bf0c928c76`. - Offline cached archive preparation passed; deliberately invalid archive was rejected with checksum mismatch before extraction. CI selector regression: all 12 fixtures passed, including an SDL pin change selecting the client gate. - Artifact sizes (not comparable performance measurements): Windows executable 14,336 bytes + SDL3.dll 1,998,848; Linux X11 executable 17,624 bytes + shared SDL 3,304,808. Build configurations/backend sets differ. No throughput or cold-build benchmark claim is made. Limits: synthetic keyboard events only; hidden Windows window and virtual Linux X11 display. No human visual inspection, real input/focus/DPI, Wayland or Linux GPU qualification. A Linux offscreen GLES attempt failed because the environment could not initialize OpenGL/GLES. No full headless CTest rerun, TSan, Docker build, remote Gitea run or Kubernetes action was performed for this gate. The new client CI job performs analysis, dummy pixel/error tests and an Xvfb window probe; remote execution remains pending. M9.1 selects a scoped dependency, not a production-ready renderer or packaged client. ## M9.2 native application and renderer boundary — 2026-10-01 Implemented ADR-0078, opt-in `evo-client`, bounded immutable presentation frames, private main-thread SDL ownership, logical/drawable size separation, focus and visibility/minimize handling, recoverable reset and terminal device-loss policy. No camera, gameplay, protocol, simulation-state or deployment changes. Executed: - Fresh Windows Release: `tools/windows-check.ps1 -Preset client -Action check` configured and built with MSVC 19.44; **3/3 client CTests passed** under NDEBUG. Also ran `build/client/evo-client-lifecycle-tests.exe` with native Windows video, then `evo-client.exe --frames 3` (default renderer) and `--renderer vulkan --frames 3`; all returned success. Earlier combined probe/client configuration passed 5/5 labeled tests. - Linux GCC 14 Release in `build/client-probe-linux`: **5/5 combined probe/client CTests passed**, as did native X11 lifecycle checks under Xvfb. The new suite executes 32 window/app destroy/recreate rounds, plus partial renderer initialization failure and hidden-window/quit behavior. It covers copied-frame independence, finite geometry/primitive limits, foreign events, focus, resize/scale queries, non-unit anisotropic scale pixel readback, hide/minimize/resume, renderer reset/loss and terminal close/error behavior. - Clang 19 Debug ASan/UBSan: `cmake --preset asan -B build/client-asan -DEVO_BUILD_CLIENT=ON -DCMAKE_CXX_COMPILER=clang++-19 -DCMAKE_C_COMPILER=clang-19 -DSDL_X11=ON -DSDL_WAYLAND=OFF`, built application and lifecycle tests, **3/3 CTests passed**. Xvfb/X11 lifecycle executable also passed with default leak detection, **no LD_PRELOAD or suppressions** after adopting direct X11 linkage. Owned libraries, app and tests are instrumented; SDL and system libraries are not comprehensively sanitizer-instrumented. - Investigated M9.1's X11 unload issue: dynamically loaded X11 configuration left 1,700,544 bytes / 31,008 allocations reported at process exit in the repeated fixture. Preloading libX11 avoided the report. SDL's supported `SDL_X11_SHARED=OFF` fixes the observed repeated-lifecycle case by retaining the linked system libraries for process lifetime. `ldd` confirms libX11 and libXext dependencies; normal X11 sanitizer run passes. This is an adopted Linux build constraint, not a claim to have repaired upstream Xlib or all native drivers. - `clang-tidy-19 -p build/client-asan` on all five new C++ translation units: passed with warnings-as-errors. Initial enum-size and multi-level pointer conversion diagnostics were corrected. Repository `format-check` passed. - Headless Release configured with **both client options OFF**, built `evo-sim` and replayed seed 123456, eight entities, 1000 ticks: unchanged hash `d61ad5bf0c928c76`, `replay_verified=true`. No SDL acquisition is part of this configure/build path. CI's isolated client stage now builds the actual app, runs static analysis and labeled checks, exercises X11 lifecycles, then instruments owned code and repeats software/X11 checks. No Docker build or remote Gitea execution was verified here. No full headless suite rerun or TSan run: headless source did not change, and this boundary requires single-main-thread use. Tests do not establish physical multi-monitor DPI, real keyboard/focus behavior, Wayland, hardware GPU loss or human visual acceptance. Those remain M9.3/M9.8 qualification work. No cluster operation was performed. ## M9.3 camera and input intentions — 2026-10-01 Implemented ADR-0079 and CAMERA_INPUT.md: SDL-free local-mm camera and held input state, explicit logical/pixel conversion, cursor-anchored zoom, bounded sequence/tick intentions and polling-before-projection. The app demonstrates arrows/wheel navigation, a WASD intention indicator and Tab UI capture. Its tick is a local fixture counter; no server/session/authoritative movement is present. Executed: - Windows MSVC 19.44 Release via `tools/windows-check.ps1 -Preset client -Action check`: 3/3 labeled tests passed. Native Windows lifecycle/input executable and the final `evo-client --frames 3` smoke passed. - Linux GCC 14 Release, existing combined probe/client build: 5/5 labeled tests passed; native Xvfb/X11 lifecycle and input events passed. The final app-only startup/error-reporting adjustment was additionally built/tested with MSVC and Clang ASan below (the GCC suite preceded that adjustment). - Clang 19 Debug ASan/UBSan: all owned camera/input/platform/app/test code built; 3/3 labeled tests and native Xvfb/X11 tests passed with leak detection enabled, without preload or suppressions. Final hidden/software three-frame app smoke also passed. SDL/system libraries remain outside comprehensive instrumentation. - Pure camera tests cover 220 world/logical/pixel round trips over four viewport/ DPI/aspect combinations and five zoom scales (1e-6 mm tolerance for fixtures), anchor preservation, pan direction, resize stability, NaN/infinity, numeric limits and unchanged state after rejected operations. - Input tests cover key release/opposites/diagonals, focus re-arm, ignored repeats, UI capture, bounded/consumed wheel accumulation, invalid input, monotonically increasing sequence/tick and stale/overflow rejection. Native SDL tests cover WASD/arrows, Tab repeat, focus loss/regain, wheel direction/pointer, minimize, saturated event batches and queued keys crossing external capture release. - clang-tidy 19 with warnings-as-errors passed on all six changed/new translation units; corrected a duplicated wheel-error branch. Final app-only adjustment also passed analysis. Repository format-check passed. - Headless Release configured with both client options OFF, rebuilt `evo-sim`, replayed seed 123456 / eight entities / 1000 ticks: unchanged `d61ad5bf0c928c76`, `replay_verified=true`. The existing client CI target now picks up the controls library and expanded lifecycle suite automatically. Docker/Gitea execution was not observed locally. No full headless suite or TSan rerun; owned client state remains main-thread-only. No physical keyboard/IME, human visual, real multi-monitor DPI, Wayland or real GPU-failure qualification is claimed from injected events and Xvfb. No network traffic, database, world mutation or deployment operation was introduced. ## M9.4 microscopic environment rendering — 2026-10-01 Implemented ADR-0080 and ENVIRONMENT_RENDERING.md: owned revision-tagged `EnvironmentPresentation` copied from M6.3 views (no tokens/store pointers), single-slot `EnvironmentLayer` ordering/freshness, and bounded camera-projected rendering with explicit missing, not-requested, present-zero, undefined-moisture and stale encodings. The app shows a local in-memory fixture authority (finite same-channel water moves via `FieldStore::transfer`); it is not a server view. Executed: - Windows MSVC 19.44 Release via `tools/windows-check.ps1 -Preset client -Action check` (run as a child `powershell.exe`): 4/4 labeled tests, including the new `client-environment` suite. App runs with `--frames 240/300`, `--refresh-every 2`, `--layer organic-carbon` exited 0; `--layer bogus` exited 2; `SDL_VIDEO_DRIVER=evo-invalid` still fails at SDL initialization (error 2), after fixture creation, so `client-init-failure` keeps testing the SDL path. - Linux GCC 14 Release (`build/client-probe-linux`, probe + client): 6/6 labeled tests; native Xvfb/X11 lifecycle suite; X11 app runs (moisture, refresh 3). - Clang 19 Debug ASan/UBSan (`build/client-asan`): 4/4 labeled tests, native X11 lifecycle, hidden X11 app (refresh 2), visible X11 moisture app and dummy-driver nitrogen app (400 frames, refresh 3) with leak detection, no suppressions. - clang-tidy 19 with warnings-as-errors on the four new/changed translation units: passed after reserving a test vector, widening a test product, and annotating two intentional out-of-range enum inputs (the rejection under test). Repository-wide clang-format 19 check passed. - Tests cover: synthetic known fields (exact ramp colour for log2 density -3, present zero, missing checker geometry, hollow unrequested outline, undefined zero-capacity moisture, collapsed small habitats); seams across chunk boundaries -16/0/16 at three zooms, three centres and two DPI ratios, compared with `Camera::world_to_screen`; voxels on the exclusive world bound; stale updates (older tick, chunk-revision regression, foreign world, regressed and pre-presentation watermarks, late-but-stale presentations, reset); failed local validation after a field transfer; unchanged field/terrain snapshots after presenting/rendering; presentations outliving their stores; 20 invalid presentation shapes; 330 camera/mode/freshness combinations over 256 cells, all within viewport, the 2313 bound, constant buffer capacity and Frame limits including host UI. - Profile (`environment_profile`, 256 visible cells, stale, nitrogen layer, checker detail): 1701 rectangles; 53,248 presentation-cell bytes; 46,260-byte reused output buffer; mean build 13.4 us (MSVC Release, this workstation), 6.6 us (GCC 14 Release, WSL2), 175 us (Clang ASan Debug). Indicative only; no frame-time threshold is claimed. - Visual sanity check: the fixture's output was rasterized offline for water, stale, nitrogen (missing), moisture and organic-carbon (not requested). This raised the not-requested outline from grey 140 to 210 for contrast with rock. This is not human/colour-vision acceptance. - Headless: a fresh MSVC Release directory with both client options OFF built `evo-sim`; seed 123456 / eight entities / 1000 ticks replayed with unchanged `d61ad5bf0c928c76`, `replay_verified=true`. Limits: pre-existing `build/release` failed to link untouched headless objects (unresolved MSVC STL `__std_rotate`/`__std_find_first_not_of_trivial_pos_1`), consistent with stale objects from a different STL build; the fresh directory above passed, and that directory was left as found. Docker/Gitea execution of the extended `ci-client` stage was not observed locally. No full headless suite or TSan rerun (headless sources unchanged; client state is main-thread-only). No physical DPI, real GPU, Wayland, accessibility or human visual acceptance is claimed. No network traffic, database, deployment or persistent format changed. ## M9.5 organism and debug views — 2026-10-01 Implemented ADR-0081 and ORGANISM_RENDERING.md: biology-derived `OrganismPresentation` (no controller/owner/level fields), `OrganismLayer` ordering/freshness, budgeted organism projection with explicit truncation, and an opt-in rectangle-only hover inspector. ImGui was evaluated as optional and not adopted. The app adds a static 48-organism fixture built from real genomes. Executed: - Windows MSVC 19.44 Release via `tools/windows-check.ps1 -Preset client -Action check` (child `powershell.exe`): 5/5 labeled tests including `client-organisms`. App runs `--frames 300 --refresh-every 2 --inspect` and `--frames 120 --layer moisture` exited 0; `--frames 0` exited 2 (usage). - Linux GCC 14 Release (`build/client-probe-linux`): 7/7 labeled tests, native Xvfb/X11 lifecycle suite, X11 app with `--inspect --refresh-every 3`. - Clang 19 Debug ASan/UBSan (`build/client-asan`): 5/5 labeled tests, X11 lifecycle, X11 app (`--inspect --layer moisture --refresh-every 2`, 300 frames) and hidden dummy-driver app (`--inspect`, 200 frames); leak detection on, no suppressions. - Organism tests: phenotype equals `derive_phenotype` (20 um cube, hand-checked bounds 390..410 at 1000 units/mm); a structured binding pins the cell's seven fields; membrane thickness cap, motility ring and ingestion mark only with the capabilities; conversion/growth/damage change body colour; visibility floor and halo; byte-identical rectangles and inspector panels for player- and NPC-controlled hosts with identical biology (ids 5 vs 900), translation-only differences when moved; death (remnant colour, no ring/mark, same size) and removal (absence, then empty presentation); 1024 visible organisms collapsing to bodies within the 1755 app budget, explicit truncation at budget 500 (498 drawn plus marker), invalid budget; a worst-case frame (environment bound + organisms + inspector + UI) within `Frame` limits; regression/foreign/watermark ordering and stale dimming; 15 invalid presentation shapes and over-capacity; topmost picking on floored bounds; gauge values and widths. - Visual sanity check (offline rasterization of the app fixture at habitat zoom and 2000 units/mm with the inspector): 3-unit floored organisms were hard to see against habitats, so the floor became 5 units with a dark halo for collapsed bodies. Not human, colour-vision or accessibility acceptance. - clang-tidy 19 with warnings-as-errors on the five new/changed translation units: passed after reserving a test vector. Repository-wide clang-format 19 passed. Limits: Docker/Gitea execution of the extended `ci-client` stage was not observed locally. No headless source changed; no full headless suite or TSan rerun. The fixture population is static presentation data, not ecology. No network, database, deployment, persistent format or simulation rule changed. ## M9.6 narrow secure dev-session protocol — 2026-10-01 Implemented ADR-0082, DEV_SESSION_PROTOCOL.md and schemas/view/dev-session-v1.md: protocol v1 codec and FrameReader, SessionAdmission, dev-only HMAC grants and a TLS 1.3-only channel over caller byte transport, using Mbed TLS 4.1.1 LTS. Dependency evidence (2026-10-01): upstream BRANCHES.md lists 4.1 as LTS supported until March 2029 (3.6 until March 2027). `mbedtls-4.1.1.tar.bz2` SHA-256 `3359a349e23db3d5536fcee032ae7b2ecbfc08972fab643089b5cbf2a375c98c` matched the release's published sha256sum file (same origin). License: Apache-2.0 OR GPL-2.0-or-later; Apache-2.0 taken, copied to third_party/mbedtls/LICENSE. Release tarballs need no Python/Perl with programs/tests off. Windows extraction skipped one symlink inside an unused upstream PQC example directory. MSVC Release static archives: mbedtls 647 KB, mbedx509 376 KB, tfpsacrypto 1.65 MB; the network test executable is 584 KB. A compile-time check proves the owned TLS 1.3-only configuration (TLS 1.2, DTLS, renegotiation, tickets, PSK modes removed) applies. Executed: - Windows MSVC 19.44 Release: `tools/windows-check.ps1 -Preset network -Action check` 1/1; `-Preset client` 5/5 after moving the SDL-free client value targets to the top-level CMake file. - Linux GCC 14 Release (`build/network-linux`): network suite passed with no owned-code warnings; existing client build 7/7. - Clang 19 Debug ASan/UBSan (`build/network-asan`): network suite passed. - libFuzzer (`evo-dev-session-fuzz`, ASan/UBSan, empty seed corpus, max_len 8192): 1,272,671 runs in 61 s (cov 685, 158-entry corpus), then 269,854 runs in 31 s after the analysis fixes; no crash, leak or canonical re-encoding abort. - Seeded mutation fuzz inside the suite: 30,000 rounds, 8,208 accepted frames, each re-encoded byte-identically. - Tests also cover: explicit little-endian Intent golden; truncated, bad magic, version 0/2, unknown type, flags, oversized, trailing and wrong-type frames; unsupported required features; grant length bounds; invalid enum bytes; views failing presentation rules; 257-cell counts; byte-by-byte reassembly and early oversized-header rejection with latching; dev keys refused in stage/world0, short/zero keys, every single-bit grant change rejected, foreign key, moved-from key; admission world/region/lifetime/skew/expiry/reuse/duplicate/capacity/ grant-table rules, every IntentStatus, rate windows and epoch advance; TLS 1.3 loopback (version, suite, frame and 100 kB transfers with 700-byte partial writes, close_notify), untrusted CA, wrong server name, mismatched private key, bad PEM, tampered record, transport failure and plaintext rejection. - clang-tidy 19 (warnings as errors) on the seven network translation units: passed after restructuring enum decoding to cast only validated bytes, reading the latched TLS error once, checking a test return value, and annotating intentional invalid-enum/use-after-move test inputs. Repository clang-format passed. CI path-selector fixtures passed including the new `network` suite. - Headless: a fresh GCC 14 Release configure with default options contained no Mbed TLS or SDL references; `evo-sim` replay of seed 123456 / 8 entities / 1000 ticks gave unchanged `d61ad5bf0c928c76`, `replay_verified=true`. Limits: the `ci-network` Docker stage and Gitea matrix entry were not executed locally. No sockets, server integration, secret provisioning or deployment exist yet (M9.7). TLS interoperability was tested only between Mbed TLS endpoints. No performance or latency measurement is claimed. Certificates in tests are throwaway; no dev CA or HMAC key was created or committed. ## M9.7 connection to one authoritative dev region — 2026-10-01 Implemented ADR-0083 and DEV_SESSION_OPERATIONS.md: non-blocking TCP (Winsock/ POSIX), `SessionServer` in evo-server's loop, `SessionClient`, evo-client remote mode, `evo-dev-session credentials|grants|probe`, the drill-time dev deployment override and `tools/ops/session-drill.sh`. Maintainer decisions (2026-10-01): proceed although M8-dev/stage is not passed; durable no-effect intentions; explicitly empty organism presentation; local real-process evidence plus a dev deployment path. Executed: - Windows MSVC 19.44 Release: `-Preset network` 1/1 and `-Preset client-network` 6/6 (network, client environment/organisms/lifecycle/smoke/init-failure). The network suite now includes four loopback session scenarios over real Winsock + TLS: connect/view/intent/durable/not-committed/replay/invalid vector; duplicate subject, reused grant, foreign key and region, capacity; stale epoch with unknown outcome, stale layers, fresh-grant reconnect and fresh baseline, and a server "restart" on the same port at a new epoch with an earlier tick; not-ready refusal without spending the grant, byte-rate flood closure (server-side decision), plaintext and silent connections dropped (the latter at the 200 ms deadline). - `evo-dev-session` on Windows: credentials written, overwrite refused (exit 1), `--environment stage` refused (exit 2), 4-grant bundle = 432 bytes. - Linux GCC 14 Release with PostgreSQL 18.6 + network (`build/m97-postgres`): network suite passed; the **full** `evo-postgres-tests` suite passed (adapter, lease, checkpoint, host, server process, the new region dev session test, recovery, ops, clone, store, load, upgrade, migration). The session process test runs real evo-server processes: dev-only and synthetic-carrier refusals (exit 2), TLS session, server-store view and empty organism layer, admitted intention whose `INT1...` request appears in the host's `ack` line at the reported tick/commit, replay rejected, duplicate session refused, SIGKILL with the client reporting loss and stale layers, successor on the same port ready after lease expiry, reconnect at epoch 2 and a second durable outcome with a higher commit. - End-to-end rehearsal on the development-v1 region (world 100, region 1, frame 9; `evo-world-clone provision`) with tool-generated credentials: probe durable ack (tick 11, commit 1); SIGKILL; successor Ready in 3472 ms at epoch 2 from committed tick 11; two `server_shutdown` refusals during recovery that did not spend grants; reconnect and second durable ack (tick 22, commit 3); `probe passed`. The **Windows** evo-client (`--connect` through WSL2 localhost forwarding, software renderer, 300 frames) then received `session welcome session=2 epoch=2 tick=45 commit=42` and exited 0. (The rehearsal script's `server2 exit=127` is a `wait` on a non-child PID in the script, not a server exit status.) - Clang 19 ASan/UBSan: network suite passed. clang-tidy 19 (warnings as errors): network library, session tests, dev tool, evo-client and evo-server/main plus the session process test all clean, after consuming best-effort results explicitly, a `must()` test helper for required optionals, and a GCC-reported genuine dangling reference in the process test fixed. Format check, CI selector fixtures and deploy policy (67 objects, 0 failures) passed; a temporary violation (`REGION_SESSION=dev`, `0.0.0.0:7400`) produced exactly the two new failures. Defects found and fixed during validation: grants were spent on `server_shutdown`/ `capacity` refusals (exhausting reconnection while a successor recovered); the session process test reused region ids 41/42 owned by the recovery suite; Mbed TLS's own `-Werror` failed on a GCC 13 `-O3` false positive (upstream warnings no longer fatal; context serialization compiled out). Limits: **no in-cluster evidence**. This workstation has no kubeconfig and Docker was stopped, so no image was built or pushed, nothing was applied to evolution-dev, and `tools/ops/session-drill.sh` has only been syntax-checked (no shellcheck available). The CI `network`, `client` and `postgres` stages with the new options were not executed remotely. Port-forward reachability of the pod-loopback listener is the documented design, not yet observed. M8-dev/stage remains not passed. The connected desktop run was hidden/software-rendered; no human visual check of remote mode. Intentions have no biological effect by design. ## M9.4–M9.7 review corrections — 2026-10-02 Responds to the review of `bb0412c..8e31932` (`.cache/reviews/M9.4-M9.7-review.md`, not in Git). All five findings were confirmed against the code and fixed: 1. **[P1] TLS retry lost queued frames.** `TlsChannel::send` is replaced by a bounded (1 MiB) `queue` + `flush`: an interrupted record is retried with identical arguments, later frames wait behind it, `close()` flushes before close_notify, a full queue returns `backpressure` without queuing. Server and client route every frame through it. Regression (`interrupted_writes`): zero progress and partial progress then zero, frames queued during the stall, both directions, exact ordered sequences; close while stalled; backpressure. 2. **[P1] Carrier ids aliased.** Carriers are server-issued `'I','N' | 48-bit epoch | 64-bit ordinal`; the client sequence is kept separately. Epochs beyond 48 bits are refused at Hello; ordinal exhaustion stops carrying. ADR-0083's low-32-bit packing is withdrawn. Regression (`carriers_never_alias`): sequences 1 and 2^32+1 get distinct ids; `not_committed` and `committed` reach their own sequences. 3. **[P2] Grants reusable after restart.** New durable `GrantLedger` (fsync before Welcome, atomic prune on open, fail closed on corruption/I-O/65536 entries), loaded into admission by a replacement process; `--session-grant-ledger` (dev: `/objects/dev-session-grants.v1`). Regressions: restart with the same ledger refuses the consumed grant and admits a fresh one; corrupt ledger refuses server creation; expired entries pruned; and in the end-to-end rehearsal the successor of a SIGKILLed evo-server refused the first, consumed grant (`closed reason=3`). 4. **[P2] No liveness after Welcome.** Protocol v1 (still undeployed) gains Heartbeat (type 9) and Close `timeout` (10). Both sides heartbeat after 1 s without output and treat 5 s of silence as dead (server closes `timeout`, freeing the subject; client marks stale, reports unknown outcomes, reconnects). Regressions (`liveness`): idle but healthy session survives 1.5 s with no ticks; a silent server is detected and reconnected to a fresh baseline; a silent client is closed and its subject reused. 5. **[P1, inherited] ci-client C compiler.** `-DCMAKE_C_COMPILER=clang-19` added; all other C-enabling fresh configures already name it. Follow-ups taken: `SessionClient::send` is bounded (256 unresolved, channel queue capacity) and refuses instead of buffering; unresolved tracking now starts at send, so a loss before IntentResult is also reported as unknown. The abuse test now floods through a raw TLS peer (the client can no longer flood) and checks the server's `rate_limited` decision. Client event-vector bounds remain M9.8 work. Executed after the fixes: Windows MSVC `network` 1/1 and `client-network` 6/6; Linux GCC 14 network suite and the **full** PostgreSQL integration suite (all suites, including the session process test with the ledger and new carrier ids); Clang 19 ASan/UBSan network suite; clang-tidy 19 (warnings as errors) on all changed network, client and server units (one `string_view::data` finding fixed in the ledger parser); libFuzzer on the amended codec, 523,479 runs in 61 s, no crash or canonicality abort; repository format, CI selector fixtures and deploy policy (67 objects, 0 failures). End-to-end rehearsal: durable ack, SIGKILL, successor Ready in 3472 ms at epoch 2, grants kept across two `server_shutdown` refusals, second durable ack, consumed grant refused by the successor, Windows evo-client welcomed (`session=2 epoch=2`), successor drained with `exit 0`. Not done: the reviewer's own reproduction binaries target the removed `send` API and were not rebuilt; equivalent regressions above replace them. The `ci-client` Docker image and Gitea pipeline were not rerun here, and no cluster operation was performed. ## 2026-10-02 — consumed-grant ledger follow-up corrections Resolved the two c588be2 review findings. Ledger open now acquires a nonblocking exclusive lifetime lock on a stable sibling file before reading or compacting (POSIX flock; Windows exclusive-sharing handle). Duplicate starts on either the same port or a different port cannot replace the active ledger. The parser caps records at 37 bytes before LF and rejects every nonempty incomplete final record before compaction, preserving the original bytes. No ledger format migration or simulation/protocol version change; valid existing files remain compatible. Regression evidence: competing SessionServer starts fail with a ledger error; the original server subsequently admits a grant, restarts, and rejects its replay. Direct competing opens return busy. Every nonempty truncation of a valid final record (including shortened numeric expiries) and an oversized line is rejected without changing the file or creating a compaction temporary. Complete/empty files and existing expired-entry compaction remain accepted. Executed: Ubuntu GCC14 network CTest 1/1; Clang19 ASan/UBSan network CTest 1/1; Windows MSVC network preset configure/build/CTest 1/1; clang-tidy19 on the changed implementation and session tests with warnings as errors, no owned diagnostics; clang-format19 on changed C++ files; git diff --check. The first restricted Windows Ninja invocation stalled without compiling; its task-owned build processes were stopped, then the same preset passed outside the restricted process environment. Not rerun: Docker/Gitea, full PostgreSQL process suite, fuzzing, TSan, or live cluster operations. No deployment performed. The text ledger detects malformed framing, not syntactically valid corruption or deletion of entire records; ADR-0083 now states that integrity limit explicitly. Client event-list bounds remain M9.8 work. ## 2026-10-02 — M9.8 decision capture and delivery segmentation Recorded confirmed platform/distribution/UI choices and deferred VM/cluster evidence in M9_8_DELIVERY_PLAN.md. ADR-0084 proposes the UI boundary and comparison; no library version or dependency was adopted. Reviewed upstream toolkit documentation, checked repository-relative links and git diff --check. Documentation only: no code tests, package build, runner execution, endpoint verification or deployment performed. ## 2026-10-02 — M9.8a pinned engineering UI probe Adopted Dear ImGui 1.92.9b for an isolated SDL3/SDL_Renderer3 compatibility probe; normal client/headless builds do not require it. Exact upstream commit, locally measured archive checksum, maintenance and notice evidence are in ADR-0084 and third_party/imgui/README.md. No upstream code modified. Embedded bitmap font used; no extra font dependency. Source preparation is explicit, with hash verification. Executed: Windows MSVC Release probe CTest 2/2; Linux GCC14 Release 2/2; Clang19 ASan/UBSan 2/2 (including instrumented toolkit sources); real X11 software renderer probes under Xvfb in Release and sanitizer builds. Three full SDL/UI initialize/render/shutdown cycles per successful invocation. A synthetic press and release activates a real widget exactly once; geometry bounds and pixel readback are checked under NDEBUG. Invalid explicit renderer fails. This is synthetic input and render evidence, not physical keyboard/DPI/accessibility acceptance. clang-tidy19 on owned probe: no owned diagnostics; clang-format19 and CI selector fixtures passed, including a new toolkit-pin selection case. Fresh headless configure with client/network/probes off passed without evaluating SDL/ImGui dependencies. An initial const mismatch with upstream's mutable draw API was corrected. Initial static analysis used a GCC database with unsupported module flags; rerun against the Clang database passed. Edited shell scripts were normalized to LF before selector fixtures ran successfully. Artifact observations: Windows Release probe EXE 398336 bytes, SDL3.dll 1998848; Linux Release executable 1098464 bytes. These are probe totals, not a final client package size or an incremental apples-to-apples benchmark. No minimum hardware, frame-rate or accessibility claim yet. Low-spec VM pending; live cluster drill is explicitly deferred; control-plane IP is not assumed to be a MetalLB endpoint. Not run: Docker/Gitea image execution, physical GPU/DPI matrix, VM soak, client UI integration/launcher or packaging acceptance. Existing network and headless simulation behavior is unchanged; no simulation version or golden was modified. ## 2026-10-02 — M9.8b owned UI state and bounded session events Implemented toolkit-independent UiState: eight expiring/dismissible notices, 240-byte messages, an observable eviction count, one id-matched modal and explicit monotonic time. Tests cover 10000-notice bursts, expiry boundary, malformed/oversized messages, stale time, deadline overflow, modal contention and stale close IDs. External native UI capture can no longer be escaped through the legacy Tab toggle. SessionClient queues at most 1024 events, reserves loss/unknown capacity, preserves queued results, and disconnects on backlog until take_events drains it. The burst regression accounts for every sent intention as a rejection or unknown, proves no grant burning while paused and confirms reconnect after drain. Backpressure is a local event, not a new wire message or simulation rule. Presets and the selective Docker client targets include the new UI state test executable. Executed: Windows MSVC client-network configure/build/CTest 7/7; Linux GCC targeted UI-state/network/native-lifecycle tests 3/3; Clang ASan/UBSan UI-state/network 2/2. Static analysis initially flagged the new test main's escaping exception; added the same process error boundary used by other executables. Windows exposed a timing assumption in the initial one-message-per-sleep burst test; bounded batches replaced that dependency. The explicit-target Windows preset initially omitted the new test binary; fixed its target list and reran all seven tests successfully. Visible dialogs/toasts, launcher and toolkit focus routing remain M9.8c. These are owned state and adapter contracts, not a claim of finished UI. No Docker/Gitea run, VM qualification, live cluster test, packaging or deployment was performed. Final additional checks: Linux GCC state/network/lifecycle 3/3; Clang ASan/UBSan native lifecycle 1/1; clang-tidy19 on owned state/session implementation, state/network tests and native adapter/lifecycle tests passed with no owned diagnostics. Final changed-file formatting passed. ## 2026-10-02 — M9.8c launcher, legend, labelled inspector and click selection Implemented toolkit-independent launcher, selection, label and outcome-log models (src/client/ui) and the toolkit overlay in the native adapter (events routed to the toolkit first; its keyboard/pointer capture suppresses world keys, wheel and clicks). The app panels show a labelled local fixture vs dev region, legend, inspector, session status with the last ten intention outcomes, notifications and a disconnect dialog. `--inspect` is replaced by click selection; `--pick`/`--screenshot` support unattended review. Added `SessionClient::unreachable_attempts()` (additive). Tests: `client-ui-model` (endpoint/field bounds, file size/shape limits, fixed error text without paths, launcher phases incl. cancel/retry, three-loss bound, refused grant, exhausted bundle; selection topmost/cell/none, disappearance clears, missing view keeps; value/zero/missing/not-requested/undefined distinct; outcome log bounds). Lifecycle `toolkit_capture`: widget click is not a world click, drag is not a click, focused text field captures keys, release needs fresh presses, screenshot hook. Network `unreachable_server`: refused connects emit no events, spend no grant, count. Executed: Windows MSVC `client` 7/7, `network` 1/1, `client-network` 8/8 (final run after all fixes). Linux: clang-19 client-probe with clang-tidy enabled (keep-going build of all client targets, no owned diagnostics after fixes) and CTest 11/11; Xvfb/X11 lifecycle, fixture (`--pick`) and launcher runs; Clang ASan/UBSan client CTest 11/11, Xvfb lifecycle and fixture; GCC 14 client-network build and client|network CTest 8/8; Clang ASan/UBSan network tests; clang-tidy on session client, network tests, app main/panels (client-network); repository format check. Visual review (dummy driver, software renderer, BMP screenshots): launcher; fixture with organism selected; fixture cell on the nitrogen layer (missing, present zero and not-requested rows distinct); connect to a closed port; live dev region (WSL development-v1 server via the M9.7 rehearsal script) with the cell inspector and Session panel. Review found and fixed: inspector values clipped (now wrapped), legend hint clipped, launcher error line overflow, Session table column mismatch, and a closed port staying "Connecting" indefinitely because pre-session failures produced no event (now bounded via the new counter; observed failing with Retry/ Cancel). Windows reports a refused loopback connect after about two seconds. Static tidy findings fixed: implicit widening in a lifecycle test, by-value lambda parameter in the UI-model test. Limits: no manual interactive session with physical mouse/keyboard, DPI matrix, screen reader or accessibility review; the remote review used one connect without WASD intentions, so the outcome list was empty in the screenshot (outcome states are covered by unit tests). No Docker/Gitea run, packaging, deployment or cluster test. No simulation version, wire format or golden changed. ## 2026-10-02 — M9.8c review corrections (.cache/reviews/m98c-review.md) 1. Same-batch panel input: pointer ownership is now resolved per SDL event from the toolkit's retained window rectangles/popup stack (pinned internal API, ADR-0084); a press on a panel owns the button until release and drops world key-downs for the rest of that batch. Regressions without settling frames: world->panel move + press/release (no world click, button still activates), move + wheel (no zoom; world wheel still zooms), click-to-focus + W in one batch (no movement; field captures; fresh press after unfocus moves). 2. Fixture/live distinction: `SessionHost` owns launcher phase and remote session; fixture, cancel, disconnect and failure drop the session; it is serviced only while connecting/connected. `client-ui-model` uses a fake session/server: connecting->fixture and failed->fixture followed by an available server produce no steps, Welcome (grant use) or intentions; ordinary connect still works. 3. Tab capture: an external release no longer cancels it. Regression drives the host order (poll, set_ui_capture(false), sample, present) over several frames, requires capture until the second toggle and a fresh, non-repeat press after. 4. Notices: wrapped text beside a reserved 22-pixel close column, width min(320, viewport-16), stack bounded to 60 % of the height with a not-shown/discarded count. New `client-panels` renders the production panels through the adapter: the three real session notices and a 240-byte message fit (content width and no horizontal scroll), the close button clicked in one batch dismisses exactly that notice with no world click; a full stack stays on screen. Negative checks: the new lifecycle test fails against the previous adapter (same- batch click), the panel test against the previous notice layout (content width), and the host-order Tab test with the former clearing restored (Windows MSVC). A GCC-only failure in the new fake-session test was a test bug (by-value argument alive until the full expression ends); split the assertion. Executed: Windows MSVC client 8/8 and client-network 9/9 (final). Linux: clang-19 client-probe build with clang-tidy enabled (keep-going, no owned diagnostics) and CTest 12/12; Xvfb/X11 lifecycle and panel tests; Clang ASan/UBSan client CTest 12/12 and Xvfb lifecycle/panels; GCC 14 client-network build, client|network CTest 9/9; clang-tidy on app main/panels (client-network); repository format check. Visual: live WSL dev region showing the wrapped connection notice with its close button. Limits unchanged: no physical mouse/keyboard session, DPI or accessibility review; the live screenshot sent no intentions. No Docker/Gitea, packaging or deployment. ## 2026-10-02 — M9.8d rebindable controls (ADR-0085) Implemented SDL-free bindings (nine actions, 92 named HID key positions, Escape reserved, modifiers/locks/system keys excluded), a staging editor with conflict refusal, and a versioned all-or-nothing controls file (4096 bytes, printable ASCII, temp-file replace). The adapter maps keys through the bindings, releases and drains on `set_bindings`, and offers binding capture ahead of the toolkit and world. The app adds a Controls panel (launcher and banner), Legend key hints, startup loading with a fixed-text notice on rejection, and `--controls FILE` / `--show-controls`. Tests: `client-bindings` (names, defaults, conflicts incl. own secondary, missing primary, reserved/modifier keys, editor refusal leaves draft unchanged, reset, serialize/parse round trip, comments/CRLF/tabs/order, unknown/duplicate/missing actions, bad names, extra tokens, non-ASCII/NUL, size bound, unsupported version, file load/save/replace, unreadable/too large/invalid/missing directory). Lifecycle `rebinding`: rebinding while held releases and drains (new key queued before the change does not act), unbound old key ignored, two keys per action never stick, rebound toggle, capture consumes the key (repeat ignored, toolkit never sees it, rest of batch drained), Escape returned, focus loss and cancel give no key. `client-panels` controls panel: fits viewport, a slot click requests capture for Move left without a world click, chosen key consumed before the toolkit. Executed: Windows MSVC client 9/9 and client-network 10/10 (final). Linux: clang-19 client-probe with clang-tidy enabled (keep-going; one test finding fixed) CTest 13/13; Xvfb/X11 lifecycle and panels; Clang ASan/UBSan CTest 13/13 plus Xvfb lifecycle/panels; GCC 14 client-network CTest 10/10; clang-tidy app main/panels (client-network); repository format check. Visual review (dummy driver, software renderer): Controls panel with a custom file (J/L/I/K, F1 + Keypad0) and matching Legend hint; invalid file (missing actions) showing "Saved controls rejected: Move left needs a primary key..." with defaults in use and the file byte-identical afterwards. Review found the startup notice expired immediately (UI clock not yet advanced); fixed. A CRLF parsing defect was found by the new test and fixed. CTest smoke runs create the empty per-user settings directory (SDL creates it on lookup); no controls file is written by tests. Not run: interactive rebinding with a physical keyboard, non-US layouts, IME, the Apply/save path end-to-end through the GUI (covered by file and editor tests), DPI, accessibility, Docker/Gitea, packaging or deployment. ## 2026-10-02 — M9.8d review corrections (.cache/reviews/m98d-review.md) 1. Toolkit keys held before capture: `begin_key_capture` drops the toolkit's key and modifier state plus queued keyboard/text events. 2. Chosen key ownership: the key stays owned across polls until release or focus loss; repeats, text and release are consumed. Also fixed (found while writing the regression): without an overlay or while paused the toolkit queue was never consumed; idle toolkit frames run and the queue is bounded at 512 events (lossy for the toolkit, never a stuck press). Tests now use realistic key events (scancode, keycode from the US fixture, down, modifiers) in lifecycle and panel suites. New lifecycle `capture_balances_toolkit`: positive controls (Q and Left Shift press and release in the toolkit), Shift+Q+W held then released during capture under external capture for choose, cancel and focus loss (all up in toolkit and world), chosen J held over three polls with repeats and text (no queued toolkit input, J never down), fresh J afterwards reaches the toolkit, owned key freed by focus loss, a 2000-event flood while hidden stays within the bound and ends released. New panel `apply_save_restart`: real adapter, production panels and `ControlsFlow` host logic; slot click arms capture, Up is refused as Pan up's key (draft keeps A), J chosen, Apply via a click writes the file and shows "Controls saved."; a restarted application loads it and J moves left. Negative checks (Windows MSVC): removing the toolkit reset fails the held-key check; removing key ownership fails the repeat/text check. Executed: Windows MSVC client 9/9, client-network 10/10 (final, after formatting). Linux: clang-19 client-probe with clang-tidy (keep-going, no owned diagnostics) CTest 13/13; Xvfb/X11 lifecycle and panels; Clang ASan/UBSan CTest 13/13 plus Xvfb lifecycle/panels; GCC 14 client-network CTest 10/10; clang-tidy app main/panels; repository format check. Limits: physical keyboards, non-US layouts and IME remain unqualified; the Apply rehearsal is automated with synthetic events, not a manual session. ## 2026-10-02 — M9.8d follow-up (.cache/reviews/m98d-followup-review.md) Owned capture keys are now a bounded set (bitset over SDL scancodes) instead of one optional key, so a second capture cannot overwrite an unreleased earlier choice. Lifecycle regressions in `capture_balances_toolkit`: W then K chosen with K released first (W repeat/text reach neither toolkit nor world until W's release, then a fresh W moves and reaches the toolkit); reverse release order (K stays owned after J's release; text flows again only when nothing is owned); cancel during a second capture keeps the first key owned; focus loss frees both; positive controls after each. Negative check: restoring single-key ownership fails the W repeat check. Executed: Windows MSVC client 9/9 and client-network 10/10 (final, after formatting). Linux: clang-19 client-probe with clang-tidy (keep-going, no owned diagnostics) CTest 13/13; Xvfb lifecycle and panels; Clang ASan/UBSan CTest 13/13 plus Xvfb lifecycle/panels; GCC 14 client-network CTest 10/10; clang-tidy app main/panels; format check. Synthetic event sequences only: physical OS repeat with several held keys, non-US layouts and IME remain unqualified. ## 2026-10-02 — M9.8e Windows client package (ADR-0086) Implemented the `client-package` preset (static MSVC runtime, `/Brepro`), the `EVO_BUILD_IDENTITY` cache value (validated, printed by `evo-client --version`), `tools/client/package-windows.ps1`, `verify-windows-package.ps1`, `package-selftest.ps1` and shared guards. Decisions confirmed by the user: static runtime; local packaging only (no workflow until a Windows runner exists); the README states an internal test build with no licence granted. Import audit: the default `/MD` client imported MSVCP140/VCRUNTIME140(_1) and api-ms-win-crt DLLs; the package build imports only KERNEL32, USER32, SHELL32, IMM32, bcrypt, WS2_32 and SDL3.dll, and SDL3.dll only Windows system DLLs. Notice audit of the compiled SDL subset found HIDAPI, yuv2rgb, stb_image and Khronos headers in addition to SDL's zlib licence; all are reproduced from the verified sources together with Mbed TLS (Apache-2.0 option) and Dear ImGui (MIT, embedded ProggyClean/ProggyForever notices, stb headers). Executed on the Windows development host (MSVC 19.44.35217, CMake 3.31.6): - Package at committed `ec1dced`: client-package CTest 10/10 inside the script; identity `gec1dcedf2e66`, ZIP 1,716,303 bytes. - Reproducibility: two `-Clean` builds into separate output directories (612 s each) gave the identical ZIP SHA-256 c0c27b948e693ac199f693f1c3ae98a7c38adefa593053273c00b41c884100a8. Same machine, path and toolchain only; other machines/toolchains are not claimed. - Verification of that ZIP: digest, exact allowlist and SHA256SUMS, PE imports, credential/profile-path scan, then the extracted client with only system directories on PATH: --version, usage error (exit 2), dummy-driver fixture (60 frames) and launcher (30 frames), missing CA file (exit 1, fixed text, no path), and `-Interactive` (default driver/renderer, real window, 180 frames); no files were written into the package folder and no controls file without Apply. - Self-test: extra/missing file, checksum mismatch, .pem and .bin files, private key and certificate text, user-profile path and a dynamic-runtime image were each refused. - Earlier dirty-tree runs found and fixed: native stderr from the child build being fatal under Windows PowerShell 5.1, the font notice extraction matching the file's table of contents (619 KB copied), and checkout-dependent line endings of the notice index. - Regular presets after the change: Windows client 9/9, client-network 10/10; Linux clang-19 tidy build 13/13, ASan/UBSan 13/13 with Xvfb, GCC 14 10/10, tidy of app main/panels, format check; `client-package` configures on Linux; an invalid identity is rejected at configure. Not done: Gitea Actions publication (no Windows runner), a run on a clean Windows VM (M9.8g), code signing, hardware/DPI qualification, legal review of notices. ## 2026-10-02 — M9.8f dev session route design (ADR-0087) Maintainer decisions: dedicated internal MetalLB VIP, TCP 7400, void.aeternalisgames.com, TLS ending in the region pod, development/test CIDR only (firewall + Service source ranges + NetworkPolicy), no Ingress/nginx TLS/PROXY protocol; operator-opened windows with server-enforced absolute expiry; scope limited to design, manifests and policy tests. Nothing was applied to the cluster. Implemented: `REGION_SESSION_LISTEN` (base stays 127.0.0.1:7400); the disabled component `deploy/kubernetes/region/dev-session-route` (LoadBalancer Service with Local policy, no node ports, pinned VIP annotation and source ranges; CIDR-only ingress policy on TCP 7400; listener patch to the pod interface) carrying REPLACE markers; policy rules for the route's exact shape, LoadBalancer/NodePort and session-port exclusivity, no session Ingress, evolution-dev-only placement, quota limits, and enabling preconditions (no markers, dev quota of exactly one LoadBalancer, server `--session-window`); patch files are now recognized generally. `tools/ci/deploy-policy-selftest.py` copies the manifests and applies 20 unsafe changes. Executed (WSL Ubuntu, Python 3 with PyYAML 6.0.1): deploy policy check on the repository, 70 objects in 68 files, 0 failures; self-test 20/20 refused, baseline copy passes; ops-lib and ci-path fixtures pass; session-drill usage unchanged. kustomize v5.4.3 (official release, SHA-256 checked against its checksums.txt, in a scratch directory, not a project dependency) rendered region/dev as committed (listener 127.0.0.1:7400, no session Service) and a temporary enabled copy with example private values (LoadBalancer evo-region-session and the CIDR policy in evolution-dev, listener 0.0.0.0:7400, session container port merged). Not run: the ci-deploy Docker stage (no Docker in this WSL distribution; its commands were run directly), any cluster/server dry-run, MetalLB allocation, DNS, firewall or live connectivity. Server-enforced session windows and the Gitea window workflow are not implemented; Argo delivery for windows and the existing void HTTP Ingress are open maintainer decisions recorded in ADR-0087. ## 2026-10-02 — M9.8f review corrections (.cache/reviews/M9.8f-9f622cf-review.md) P1 (rendered configuration): the policy check now renders all 17 non-component kustomizations with pinned kustomize v5.8.1 (ADR-0088; official archive, SHA-256 029a7f0f…a819d checked against the release checksums) and validates the effective objects: overlay namespaces, evo-region session/input/listener environment, a single listener argument, container ports, Service types and session port, route shape, session NetworkPolicies, quotas, Ingresses and no Secrets. Unsupported kustomize features (plugin generators/transformers, Helm, Secret generators) are refused. Route enabling is gated by `ROUTE_ENABLING_PERMITTED = False`, changed only with an ADR-0087 amendment recording the implemented window contract and runtime expiry tests; the earlier `--session-window` string test is gone. Route addresses must be RFC 1918 or listed in `APPROVED_INTERNAL` (empty; 172.10.1.x is not RFC 1918). P2 (health-check port): manifest comment and ADR-0087 now state that the Local policy allocates `healthCheckNodePort`; allocation, quota accounting and firewall handling are enabling preconditions. Review recommendations (manual Argo sync, preserving the void endpoint, address confirmation, window limits and tests) are recorded in ADR-0087 as pending maintainer decisions. The M9.8f gate stays open. Executed (WSL Ubuntu, Python 3, PyYAML 6.0.1, kustomize v5.8.1 via the new prepare script, idempotent on rerun): policy check 70 source objects / 126 rendered objects in 17 overlays, 0 failures; self-test 33/33 refused (20 earlier cases plus non-RFC 1918 VIP, the reviewer's combined inline patches, inline listener/session/input patches, JSON patches adding a session port, a LoadBalancer, a container port and a second listener argument, namespace transformation, inline stage quota, Secret generator, Helm inflation); the reviewer's m98f-policy-repro.py now exits 1 with the listener, session/input and ops-port failures in both region/dev and dev; the check fails without kustomize and with kustomize v5.4.3; ops-lib and ci-path fixtures pass. Not run: the ci-deploy Docker stage (no Docker here; its commands were run directly, including prepare-kustomize.sh), any cluster dry-run or live action. ## 2026-10-02 — M9.8f review of 8a1e5ef (.cache/reviews/M9.8f-8a1e5ef-review.md) P2: rendered NetworkPolicies are now checked by effect: the default-deny contract in every environment namespace, and every ingress rule able to select a region pod (empty/expression selectors included) is refused if it admits the session port (no or empty ports, port-less TCP entries, the `session` name, 7400, ranges spanning it), except the fully validated route policy. Activation follow-up done now: the route Service and policy validators (VIP, source ranges, annotations, selector, shape) are shared by the source and rendered checks. Executed (WSL, kustomize v5.8.1): policy check 0 failures (126 rendered objects, existing ops/metrics scrape rule accepted); self-test 44/44 refused, adding the reviewer's all-ingress default-deny patch, region policies without ports, with empty ports, by the session name, by a 7000-8000 range, an every-pod policy on 7400, an expression selector, a port-less entry, and rendered route patches of the selector, VIP and source range; the reviewer's m98f-8a1e5ef-repro.py now exits 1 with default-deny and session-port failures in platform/dev and platform/cluster. No cluster action. M9.8f remains open. ## 2026-10-03 — M10.1 protocol timing and workload budgets (ADR-0089) Maintainer ratified: 50 ms tick, 1 s flush with final outcomes p95 <= 1.5 s, responsiveness LAN p95 <= 150 ms / 100 ms RTT p95 <= 250 ms, server budgets on one RKE2 worker and client budgets on the low-spec VM. Derived budgets and the exact/tolerant determinism contract are in ADR-0089 and schemas/network/m10-budgets-v1.md. Implemented: `SessionClient::traffic()` received-frame counters (additive API, checked in network_session); `evo-dev-session trace` (continuous polling, nearest-rank percentiles, CSV); `tools/network/session-trace.sh` (throwaway PostgreSQL, development-v1 region, evo-server with sessions and ops metrics, three loopback runs, cross-host pause). Traces (development reference: Ryzen 7 9800X3D, 61.6 GB, Windows 11; WSL2 server): committed-script run with Linux loopback at 250/100/1000 ms and Windows -> WSL2 at 250 ms: admission p50 0.9-1.4 ms, p99 <= 5.2 ms; durable p50 0.92-1.06 s, p95 1.37-1.41 s, max 1.46 s; outcome lead 9 ticks; view interval p50 50.1 ms, p99 <= 60 ms; 267-byte views, about 7.5 KB/s; tick debt max 0, server about 1 % CPU, 10.5 MB RSS. Two earlier runs matched within about 1 ms. A 1 ms-sleep Windows client measured about 31 ms admission (Windows timer granularity); the trace now polls continuously. Finding recorded in ADR-0089: genome v1 and metabolism rates are per tick, so the quantum fixes biological rates; changing it needs a versioned rules migration (M11.1). Executed checks: Windows MSVC network preset 1/1 (twice, after each change); Linux GCC 14 network tests and evo-dev-session build; Clang ASan/UBSan network tests; clang-tidy on the session client, evo-dev-session and network_session tests; format check. Not covered: emulated RTT/loss, multiple clients, the reference worker and low-spec VM, movement/prediction; the targets are therefore not yet qualified (10.9).