diff --git a/CMakeLists.txt b/CMakeLists.txt index 06cd865..2d4d32c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -695,6 +695,16 @@ endif() if(BUILD_TESTING) add_executable(evo-cellular-population-tests tests/cellular_population_tests.cpp) + add_executable(evo-cellular-inheritance-tests tests/cellular_inheritance_tests.cpp) + target_link_libraries(evo-cellular-inheritance-tests PRIVATE evo::lifecycle) + evo_owned_target(evo-cellular-inheritance-tests) + add_test(NAME cellular-inherited-plans COMMAND evo-cellular-inheritance-tests) + set_tests_properties(cellular-inherited-plans PROPERTIES TIMEOUT ${evo_cohort_timeout}) + add_test(NAME cellular-inheritance-process-restart COMMAND "${CMAKE_COMMAND}" + "-DPOPULATION_TEST=$" + "-DTEST_DIR=${CMAKE_CURRENT_BINARY_DIR}/inheritance-restart" + -P "${CMAKE_CURRENT_SOURCE_DIR}/tests/cellular_population_restart.cmake") + set_tests_properties(cellular-inheritance-process-restart PROPERTIES TIMEOUT ${evo_cohort_timeout}) add_executable(evo-cellular-maturation-tests tests/cellular_maturation_tests.cpp) target_link_libraries(evo-cellular-maturation-tests PRIVATE evo::lifecycle) evo_owned_target(evo-cellular-maturation-tests) diff --git a/README.md b/README.md index fb99b02..af3f7c3 100644 --- a/README.md +++ b/README.md @@ -203,6 +203,14 @@ runs the declared 80,000-tick development/hold-out matrix with raw/cohort equali whole-genome conversions, restores and resource controls. This is bounded ecology evidence, not actual-days or product acceptance. +The opt-in [retained offspring-plan owner](docs/adr/0165-retained-cellular-offspring-plans.md) +keeps parent anatomy separate from earned inherited changes and repeatedly funds +offspring from the saved plan. Build `evo-cellular-inheritance-tests`; CTest +`cellular-inherited-plans` and `cellular-inheritance-process-restart` cover its +portable contract. [Format 8](schemas/cellular-lives-v8.md) is not admitted to +existing durable bundles or live entry. Control succession and behavior/UI +integration remain pending. + M5.1 local voxel/address API and scope: [local voxel contract](docs/world/LOCAL_VOXEL_CONTRACT.md). M5.8 process restart proof and measured costs: [world proof](docs/engineering/WORLD_PROOF.md). diff --git a/deploy/kubernetes/region/dev-session-route/listener.yaml b/deploy/kubernetes/region/dev-session-route/listener.yaml index 766de3b..6855832 100644 --- a/deploy/kubernetes/region/dev-session-route/listener.yaml +++ b/deploy/kubernetes/region/dev-session-route/listener.yaml @@ -12,7 +12,7 @@ spec: env: - {name: REGION_SESSION, value: "dev"} - {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"} - - {name: REGION_SESSION_WINDOW, value: "dev-20261019T170913-a5535407:1792444153"} + - {name: REGION_SESSION_WINDOW, value: "dev-20261019T173417-a98f9f06:1792445657"} - {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"} ports: # QUIC (ADR-0090): UDP only; nothing listens on TCP 7400. diff --git a/docs/STATUS.md b/docs/STATUS.md index 2c9bb59..32d64de 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -1,5 +1,20 @@ # Project status and next steps +## Portable retained offspring plans - 2026-10-19 + +[ADR-0165](adr/0165-retained-cellular-offspring-plans.md) implements an opt-in +stored-plan owner, format 8/rules 10. Earned selections edit the inherited plan; +the parent's expressed body and biological charges stay unchanged. Repeated +funded births use that plan, later selections preserve earlier siblings, and +reloads/death history retain the distinction. Older saves retain their meaning. + +MSVC/GCC full Release suites pass **85/85**; exact separate-process inherited +continuations agree across compilers. [Validation](engineering/VALIDATION.md) +records analysis/sanitizer evidence and scope. Current durable bundles, census, +population, migration and old batch replay refuse the new owner. Durable plan +integration, the in-life expression catalog, birth-time control succession, +retained NPC behavior and choice UI remain open. M12 remains in progress. + ## Distinct-genome offspring funding - 2026-10-19 [ADR-0164](adr/0164-distinct-genome-offspring-funding.md) implements the first diff --git a/docs/adr/0165-retained-cellular-offspring-plans.md b/docs/adr/0165-retained-cellular-offspring-plans.md new file mode 100644 index 0000000..c430195 --- /dev/null +++ b/docs/adr/0165-retained-cellular-offspring-plans.md @@ -0,0 +1,83 @@ +# ADR-0165: Retained cellular offspring plans + +## Status and scope + +Accepted for the portable stored-plan segment of ADR-0163/0164, 2026-10-19. +No default/DEV upgrade, SQL admission, player succession or NPC behavior policy. +This is an explicit offspring-plan editing mode, not a final classification of +which future mutation operators may also be expressed during an existing life. + +## Decision + +Add cellular owner format 8/rules 10 through a detached no-tick upgrade from +format 7/rules 9. Preserve all biology, inventories, identities, offers, boundary +flows and archive history. Initialize each living/corpse offspring plan to its +currently expressed genome. Older formats retain zero in the new in-memory +fields and omit them from their unchanged canonical bytes. + +`identity.genome` and archive `current_genome` keep their expressed-body meaning. +The separate `offspring_genome` names the inherited developmental plan. Every +newborn starts with both references naming the actual inherited plan. Existing +body derivation, maintenance, movement, feeding, growth, damage, predation and +spatial exclusion always use the expressed genome. Corpses retain the last +offspring plan as history, with no reproductive viability granted to dead tissue. + +In this opt-in editing mode, the existing earned mutation choice edits the +offspring plan. Draw from the current plan using the existing recorded context +and eligibility credit. Revalidate selections exactly; admit the successor genome +without adding an expressed-genome revision or constructing parent tissue. +Consume the offer once. Record `(life,previous_plan,successor_plan,tick)` in an +append-only log, bounded by the existing genome archive capacity. Operator zero +still declines. NPCs still earn no mutation offers. No extra mutation fee is +invented: physical construction is funded when an actual offspring is made. +The live-expression path for nonstructural traits requires a later operator +catalog/transaction contract; this mode supplies only offspring-plan selections. + +Use ADR-0164 mixed-genome funding for buds and their exact twin eligibility. +Retain existing phase order: surviving-parent plan selection precedes budding; +newborns do not grow or bud in their birth tick. Thus a selected plan can affect +that tick's offspring while the parent's expressed body remains unchanged. The +child's birth archive record names its actual inherited genome. Later selections +affect later offspring only. Wildlife reproduction uses the actual plan cost. + +## State and restore invariants + +Format 8 extends the format-7 header by a u32 plan-history count and zero u32 +reserved field (316 bytes total). Each living/corpse row appends one u64 plan +reference (512/132 bytes). After habitat, archive and nonresident IDs, append +32-byte history rows in increasing `(tick,life)` order, then the existing FNV +trailer. Preserve the 16 MiB owner bound and existing archive limits. The magic is +`AEVCLV08`; only rules 10 uses this format. No native-layout serialization. + +Validate counts/size before allocation, all plan references, compatible schema/ +development versions, and each complete per-life chain from its expressed genome. +History successors have one genome parent matching the recorded previous plan +and their recorded origin matches the selected successor identity. Require unique +successors, live-at-selection timing, retained actor identity, and final references +matching the log. Selections must follow any legacy expressed-body revision used +as their initial plan. Regenerate outstanding offers from the retained current plan. +Missing, conflicting, forged, over-bound or noncanonical state refuses atomically. + +## Alternatives, benefits, costs and risks + +Overwriting the parent's expressed genome would rebuild it and misprice its body. +Treating an unexpressed plan as an archive living carrier invents an organism. +Keeping only a final reference loses which parent selected earlier sibling plans. +The distinct reference/log preserves body and ancestry meanings at bounded cost. + +A plan without expressed carriers may still be reproductively available in a +living parent. Existing census, migration, population and persistence allowlists +must refuse this new owner until they have complete plan/viability semantics and +versioned replay; absence of expressed carriers cannot prove its extinction. +No old snapshot or golden is rewritten. This portable checkpoint is not durable +publication authority, and no existing SQL bundle admits it. + +## Qualification + +Require real earned plan selections, unchanged parent anatomy/biological charges, +different funded sibling plans, later choices leaving earlier children unchanged, +exact save/restore and separate-process continuation, death/history retention, +offline exclusion, all-channel closure, unsupported old paths and forged codecs. +Run Release/NDEBUG, analysis, formatting and relevant ASan/UBSan checks. Retained +plans do not implement the birth-time control choice, persistent NPC behavior, +new limb/plant traits, UI, environmental producers or M12 completion. diff --git a/docs/adr/README.md b/docs/adr/README.md index 676ceef..c4fb1d6 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -1,5 +1,7 @@ # Architecture decision records +- [ADR-0165: Retained cellular offspring plans](0165-retained-cellular-offspring-plans.md) - portable owner format 8/rules 10 keeps expressed bodies separate from earned inherited plans, repeated births and selection history; durable/control/UI integration pending. + - [ADR-0164: Distinct-genome offspring funding](0164-distinct-genome-offspring-funding.md) - pure funded reproduction separates the expressed parent's investment from the inherited child's anatomy and provision; old same-genome behavior retained, owner/control integration pending. - [ADR-0163: Structural inheritance and one-way offspring succession](0163-structural-inheritance-and-offspring-succession.md) - maintainer-accepted target gameplay: offspring structural traits, irreversible birth-time control choice and NPC-parent behavior/reproductive continuity; implementation pending. diff --git a/docs/biology/REPRODUCTION_MODEL.md b/docs/biology/REPRODUCTION_MODEL.md index 7a6ff82..57d07b8 100644 --- a/docs/biology/REPRODUCTION_MODEL.md +++ b/docs/biology/REPRODUCTION_MODEL.md @@ -16,10 +16,10 @@ are living is a different event. Each organism keeps its own identity, inventory development, ancestry and terminal death. Only the currently controlled organism freezes on logout; independent parents and siblings continue living normally. -Implementation remains pending. Separate expressed/heritable state and bounded -NPC behavior, versioned mutation timing and a durable birth/control choice must -be implemented before this behavior is offered. Choice timing and pause policy -remain explicit implementation decisions. The M11 decisions and diagram below +Portable expressed/heritable state is now implemented below. Bounded NPC +behavior and a durable birth/control choice must be implemented before this +behavior is offered. Choice timing and pause policy remain explicit implementation +decisions. The M11 decisions and diagram below describe the old baseline, not a prohibition on the accepted target behavior. ## Implemented portable offspring funding @@ -34,9 +34,25 @@ refuse. Two share-funded children cannot manufacture the parent's invested matte Tests cover changed anatomy and demand, sterile children, exact cost/shortages, twins and retained archive identities. Existing same-genome helpers delegate to -this operation with identical parent/child inputs. This is a pure proposal; -stored heritable state, mutation expression timing, succession, NPC behavior and -birth UI remain unimplemented. Current live rules still produce exact-copy buds. +this operation with identical parent/child inputs. Current live rules still +produce exact-copy buds. + +## Implemented portable retained plans + +[ADR-0165](../adr/0165-retained-cellular-offspring-plans.md) adds opt-in owner +format 8/rules 10. Expressed genome IDs keep describing existing tissue. Earned +mutation choices in this mode edit a separate offspring plan, without rebuilding +the parent or charging for unconstructed tissue. Physical construction is funded +at birth. Subsequent offspring use that plan until another selection changes it; +earlier children keep their original form. Save/reload retains plan selections +and dead-parent history, and logout freezes the controlled parent's biology. + +This scoped mode edits inherited plans only. The future operator catalog still +needs to distinguish traits that can also change during an existing life. Existing +durable bundles, census, population, migration and batch replay refuse the new +owner until their plan semantics are qualified. The birth-time control choice, +persistent NPC behavior and UI remain unimplemented; default/DEV rules do not +opt into this owner. ## Historical M11 baseline and open strategies diff --git a/docs/engineering/M12_REMAINING_GATES.md b/docs/engineering/M12_REMAINING_GATES.md index 6c91474..dc8a8cb 100644 --- a/docs/engineering/M12_REMAINING_GATES.md +++ b/docs/engineering/M12_REMAINING_GATES.md @@ -7,15 +7,19 @@ Completed scoped commits do not mean their entire roadmap gates have passed. The maintainer's 2026-10-19 [gameplay clarification](../adr/0163-structural-inheritance-and-offspring-succession.md) accepts offspring structural expression, a one-way birth-time control choice and -NPC-parent behavior/reproductive continuity. Current mutation, controller, birth, -control and census state do not implement that target. These require coordinated -versioned biology, authority, recovery and UI work; earlier exact-copy generation +NPC-parent behavior/reproductive continuity. Portable retained plans implement +part of that target; durable mutation/birth, behavior, control and census still +require coordinated versioned biology, authority, recovery and UI work. Earlier +exact-copy generation evidence does not close that gap or establish the intended generational gameplay. [ADR-0164](../adr/0164-distinct-genome-offspring-funding.md) now implements the pure biological funding step with distinct parent/offspring genomes and exact -closure. Existing same-genome behavior remains. Persistent heritable plans, -expression timing, authority handoff and NPC/UI integration are still required. +closure. [ADR-0165](../adr/0165-retained-cellular-offspring-plans.md) adds portable +retained plans and earned selections, unchanged expressed parents and repeated +funded births. Existing same-genome behavior remains. Durable plan/trace/bundle, +population/migration/census admission, the in-life expression catalog, authority +handoff and NPC/UI integration are still required. ## Persistence boundary resolved by 12.3b diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 7b24b06..481ecbb 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -1,5 +1,64 @@ # Validation report +## 2026-10-19 - Portable retained cellular offspring plans + +[ADR-0165](../adr/0165-retained-cellular-offspring-plans.md) adds opt-in owner +format 8/rules 10, an explicit no-tick upgrade, separate expressed/inherited +genomes and append-only plan selections. Earned selections change inherited +plans without rebuilding/charging parent tissue; actual births fund the child's +plan. Existing raw/population/durable versions keep their meaning. Old raw batch +replay now explicitly refuses this new unsupported owner. + +Executed locally: + +- MSVC 19.44 Release full CTest **85/85 passed, 21.91 s**, with NDEBUG. +- GCC 14.2 Release full CTest **85/85 passed, 16.83 s**, with NDEBUG. +- Clang 19.1 Debug inheritance contract and actual separate-process restart + **2/2 passed, 11.74 s**, built with clang-tidy 19 enabled. All changed C++ + implementations and the new test compiled under that analysis configuration. + Repository clang-format 19 and diff whitespace checks pass. +- Clang 19.1 ASan/UBSan budding, inherited funding, retained plans, inheritance + process restart and funded maturation **5/5 passed, 70.52 s**, without reports. + After strengthening valid-trace refusal, the two inheritance tests passed again + under ASan/UBSan, **2/2, 40.26 s**; production C++ was unchanged. +- Optional GCC cellular session adapter rebuilt; `cellular-session-batch` + **1/1 passed, 0.14 s**. No private PostgreSQL integration rerun: schema, + SQL admission and durable bundles are unchanged and do not admit this owner. + +Tests exercise actual earned structural offers, declines, stale/reused selection +refusal without state changes, unchanged parent body/reserve/heat versus an +unselected control, no fictitious archive carriers, repeated funded siblings, +later plans preserving earlier children, exact reload, suspended-parent exclusion, +ordinary ecological death and retained corpse plans. A legacy expressed mutation +survives upgrade, and a forged selection predating that expression refuses. +Checksummed hostile references, actor/history timing, counts, reserved fields, +version mismatch and checksum damage refuse; unsupported population/census/ +migration/replay paths also refuse. The replay test uses a valid encoded/decoded +old trace and requires the version refusal specifically. Inventory closes in +every channel. + +The restart fixture writes a selected plan and actual offspring, continues 64 +ticks with the controlled parent frozen and offspring metabolism active, and +compares against a separate process restoring that cut. MSVC and GCC final bytes +also have identical SHA-256 +`1e2c254df2d38b6cca1444c272a05563eec934e4381653240280958eee107837`. +The initial restart assertion incorrectly required juvenile growth even though +maximal funded birth can already be fully grown. It was corrected to require +real offspring metabolism and plan retention; all checks above ran afterward. +No golden or biological rule was changed to satisfy it. + +This is portable checkpoint evidence, not durable publication, live deployment, +controller behavior continuity, control succession or UI qualification. No +target-host/TSan/actual-days evidence or M12 completion is claimed. The fixtures +use finite food and scripted intentions to isolate owner semantics; they do not +replace the separate unscripted ecology matrix. The in-life trait expression +catalog and broader plan viability semantics remain open integration work. + +The DEV window in this push expires **2026-10-19 21:34:17 UTC**. Rendered policy +passes: 75 objects in 74 files, 138 rendered objects in 17 overlays, zero failures. +The unchanged policy self-test matrix was not repeated. No deployment or World0 +operation occurred; unrelated untracked files were preserved. + ## 2026-10-19 - Distinct-genome offspring funding [ADR-0164](../adr/0164-distinct-genome-offspring-funding.md) adds a complete pure diff --git a/include/evo/server/lifecycle/cellular_batch.hpp b/include/evo/server/lifecycle/cellular_batch.hpp index 50d1b5f..ed92195 100644 --- a/include/evo/server/lifecycle/cellular_batch.hpp +++ b/include/evo/server/lifecycle/cellular_batch.hpp @@ -98,6 +98,7 @@ decode_cellular_batch(std::span bytes); // Replays from an immutable predecessor snapshot. The caller must first bind the // header identity, predecessor commit/digest and tick range to trusted manifests. // Every tick must cover its living set; the caller compares the returned snapshot. +// Owner format 8/rules 10 requires separately qualified trace admission and is refused. [[nodiscard]] std::expected, CellularBatchError> replay_cellular_batch(const CellularLives& base, const CellularBatch& batch); // The same replay, also reporting every mutation selection's final result in trace order diff --git a/include/evo/server/lifecycle/cellular_lives.hpp b/include/evo/server/lifecycle/cellular_lives.hpp index aa1574b..5ee2bb0 100644 --- a/include/evo/server/lifecycle/cellular_lives.hpp +++ b/include/evo/server/lifecycle/cellular_lives.hpp @@ -47,6 +47,9 @@ inline constexpr std::uint32_t cellular_lives_foraging_rules = 8; inline constexpr std::uint32_t cellular_lives_migration_format = 7; // ADR-0157: opt-in funded maturation, using the unchanged format-7 fields. inline constexpr std::uint32_t cellular_lives_maturation_rules = 9; +// ADR-0165: explicit offspring-plan editing mode; expressed bodies retain their genomes. +inline constexpr std::uint32_t cellular_lives_inheritance_format = 8; +inline constexpr std::uint32_t cellular_lives_inheritance_rules = 10; inline constexpr std::uint32_t cellular_growth_per_tick = 5; // Per 50 ms; trial rate. // The founder a region of these rules creates. [[nodiscard]] constexpr biology::FounderVersion @@ -94,7 +97,7 @@ struct CellularMutationProgress { struct CellularOwnedLife { LifeAccount account{}; - LifeAllocation identity{}; + LifeAllocation identity{}; // genome always identifies the expressed body. std::uint64_t source{}; biology::GrowthState growth{}; biology::CellularPosition position{}; @@ -105,6 +108,7 @@ struct CellularOwnedLife { // Format 6 (ADR-0128): presence and the tick its freeze began (zero while active). CellularPresence presence{CellularPresence::active}; std::uint64_t frozen_since{}; + std::uint64_t offspring_genome{}; // Format 8; older formats retain zero. auto operator<=>(const CellularOwnedLife&) const = default; }; struct CellularOwnedCorpse { @@ -117,8 +121,9 @@ struct CellularOwnedCorpse { std::uint32_t extent_um{}; accounting::Inventory inventory{}; // Empty under rules 3: it became detritus. biology::CellularDeathCause cause{biology::CellularDeathCause::unrecorded}; - std::uint64_t predator_life{}; // Engulfed only. - std::uint64_t parent_life{}; // Format 5: kept after death. + std::uint64_t predator_life{}; // Engulfed only. + std::uint64_t parent_life{}; // Format 5: kept after death. + std::uint64_t offspring_genome{}; // Format 8: retained plan, not living stock. auto operator<=>(const CellularOwnedCorpse&) const = default; }; struct CellularBoundaryLedger { @@ -126,6 +131,13 @@ struct CellularBoundaryLedger { std::vector nonresident_organisms; // Retained history, never activity. bool operator==(const CellularBoundaryLedger&) const = default; }; +struct CellularOffspringRevision { + std::uint64_t life{}, previous{}, successor{}, tick{}; + auto operator<=>(const CellularOffspringRevision&) const = default; +}; +[[nodiscard]] constexpr std::uint64_t cellular_offspring_genome(const CellularOwnedLife& life) { + return life.offspring_genome == 0 ? life.identity.genome : life.offspring_genome; +} class CellularMigration; struct CellularLifeIntent { std::uint64_t life_id{}; @@ -142,7 +154,8 @@ enum class CellularMutationResult : std::uint8_t { applied, life_died, insufficient_funding, - declined + declined, + offspring_plan_applied // Rules 10: inherited plan changed, expressed body did not. }; struct CellularMutationExecution { std::uint64_t life_id{}, successor_id{}; @@ -266,6 +279,10 @@ class CellularLives { // ADR-0157: detached no-tick rules-8/format-7 -> rules-9 candidate. No grant. [[nodiscard]] std::expected, CellularLivesError> maturation_upgrade_candidate() const; + // ADR-0165: explicit no-tick format-7/rules-9 -> format-8/rules-10 upgrade. + [[nodiscard]] std::expected, CellularLivesError> + inheritance_upgrade_candidate() const; + [[nodiscard]] std::span offspring_revisions() const noexcept; // Latest successful in-memory step report; omitted from snapshots and empty after restore. [[nodiscard]] std::span last_tick_feedback() const noexcept; [[nodiscard]] std::vector snapshot() const; @@ -301,6 +318,7 @@ class CellularLives { advance_tick(std::span intents); // Mutation selections are validated against the predecessor offer, then applied // after the normal life step and before births on the same advancing tick. + // Rules 10 edit only the retained offspring plan; parent tissue is unchanged. [[nodiscard]] std::expected advance_tick_with_mutations(std::span intents, std::span selections); diff --git a/schemas/cellular-lives-v8.md b/schemas/cellular-lives-v8.md new file mode 100644 index 0000000..00b63d4 --- /dev/null +++ b/schemas/cellular-lives-v8.md @@ -0,0 +1,51 @@ +# Cellular owner format 8: retained offspring plans + +Authority: [ADR-0165](../docs/adr/0165-retained-cellular-offspring-plans.md). +Portable opt-in format 8/rules 10 only. No existing durable bundle, population +envelope, batch trace, migration or census adapter admits this version. Earlier +canonical formats and their meanings are unchanged. + +Little-endian, no native padding. Magic `AEVCLV08`. The first 308 bytes retain +[format 7](cellular-lives-v7.md), except magic/format/rules. Extensions: + +| Offset | Bytes | Field | +|---:|---:|---| +| 308 | 4 | Offspring-plan revision count, at most 4096 | +| 312 | 4 | Reserved zero | +| 316 | 8 each | Sorted spawn sites | +| after sites | 512 each | Existing 504-byte living record, then u64 offspring genome | +| after lives | 132 each | Existing 124-byte corpse record, then u64 offspring genome | +| after corpses | declared lengths | Complete canonical habitat and lineage archive | +| after archive | 8 each | Sorted unique nonresident organism IDs | +| after nonresidents | 32 each | Offspring-plan revisions | +| final | 8 | FNV-1a64 of all preceding bytes | + +Each plan revision contains four u64s: life ID, previous genome ID, successor +genome ID and selection tick. Records increase by `(tick, life)`, strictly within +each tick. Successor IDs are unique. The exact length is +`316 + 8*sites + 512*lives + 132*corpses + habitat_bytes + archive_bytes + +8*nonresidents + 32*plan_revisions + 8`, at most 16 MiB. Check counts, lengths, +reserved fields and checksum before nested allocation/restore. The checksum +detects corruption; it supplies no publication authority. + +Living identity genome and archive current genome describe expressed anatomy. +Every local living/corpse plan reference is nonzero and resolves in the archive. +Initialize its chain from the expressed genome. Each selection must name that +life's preceding plan and a direct single-parent successor whose origin event is +its own ID, with matching genome schema/development versions. Selections follow +birth and any legacy expressed revision, precede death and cannot be in the +future. Only existing controlled founders select plans in this version. A +successor cannot have an earlier recorded local birth. Final references must +match complete retained chains. Outstanding offers regenerate from the current +plan and their original context. All existing identity, presence, tissue, +inventory, boundary-flow and archive invariants still apply, followed by exact +canonical re-encoding. + +The detached no-tick format-7/rules-9 upgrade preserves all old state and gives +each local living/corpse record its current expressed genome as its initial +offspring plan. No prior selections are invented. Newborns express the plan +actually funded at birth and initialize their own plan to that genome. Corpses +retain plans as history, without reproductive viability. Unexpressed plans own +no stock and are not archive living carriers; a living parent can nevertheless +retain one for future reproduction. Terminal extinction needs broader viability +semantics before census/persistence integration. diff --git a/src/server/lifecycle/cellular_batch.cpp b/src/server/lifecycle/cellular_batch.cpp index 67fb311..9e38ea1 100644 --- a/src/server/lifecycle/cellular_batch.cpp +++ b/src/server/lifecycle/cellular_batch.cpp @@ -407,6 +407,9 @@ std::expected, CellularBatchError> replay_cellular_batch(const CellularLives& base, const CellularBatch& batch, std::vector& mutation_outcomes) { mutation_outcomes.clear(); + // ADR-0165: this trace has no admitted offspring-plan outcome contract. + if (base.format_version() >= cellular_lives_inheritance_format) + return std::unexpected{CellularBatchError::version}; const auto& h = batch.header; if (!valid_header(h, batch.ticks.size()) || !valid_ticks(batch.ticks)) return std::unexpected{CellularBatchError::format}; diff --git a/src/server/lifecycle/cellular_lives.cpp b/src/server/lifecycle/cellular_lives.cpp index a3135f9..f028364 100644 --- a/src/server/lifecycle/cellular_lives.cpp +++ b/src/server/lifecycle/cellular_lives.cpp @@ -6,7 +6,9 @@ #include #include #include +#include #include +#include #include #include @@ -19,6 +21,7 @@ constexpr std::uint64_t cellular_lives_v4_magic = 0x3430564C43564541ULL; // AEVC constexpr std::uint64_t cellular_lives_v5_magic = 0x3530564C43564541ULL; // AEVCLV05 constexpr std::uint64_t cellular_lives_v6_magic = 0x3630564C43564541ULL; // AEVCLV06 constexpr std::uint64_t cellular_lives_v7_magic = 0x3730564C43564541ULL; // AEVCLV07 +constexpr std::uint64_t cellular_lives_v8_magic = 0x3830564C43564541ULL; // AEVCLV08 constexpr std::size_t cellular_lives_header_bytes = 212; constexpr std::size_t cellular_site_bytes = 8; constexpr std::size_t cellular_life_v1_bytes = 168; @@ -35,6 +38,8 @@ constexpr std::size_t cellular_corpse_v5_bytes = cellular_corpse_v4_bytes + 8; constexpr std::size_t cellular_life_v6_bytes = cellular_life_v5_bytes + 16; // Format 7: two boundary-flow inventories and nonresident count/reserved. constexpr std::size_t cellular_lives_v7_header_bytes = cellular_lives_v5_header_bytes + 88; +constexpr std::size_t cellular_lives_v8_header_bytes = cellular_lives_v7_header_bytes + 8; +constexpr std::size_t cellular_offspring_revision_bytes = 32; std::uint64_t checksum(std::span bytes) noexcept { std::uint64_t value = 14695981039346656037ULL; @@ -276,6 +281,84 @@ sum_state(accounting::Inventory nursery, accounting::Inventory heat, return total; } +bool validate_plans(std::span lives, + std::span corpses, + const biology::LineageArchive& archive, + std::span history, std::uint64_t tick) { + if (history.size() > biology::max_archived_genomes) + return false; + struct Plan { + std::uint64_t life, expressed, current, final, editable_after, died; + bool selectable; + }; + std::vector plans; + std::map earliest_birth; + std::map last_expression; + for (const auto& revision : archive.revisions()) + last_expression[revision.organism] = + std::max(last_expression[revision.organism], revision.at.value); + const auto observe = [&](std::uint64_t genome, std::uint64_t born) { + const auto [position, inserted] = earliest_birth.emplace(genome, born); + if (!inserted) + position->second = std::min(position->second, born); + }; + plans.reserve(lives.size() + corpses.size()); + for (const auto& life : lives) { + plans.push_back( + {life.identity.life, life.identity.genome, life.identity.genome, life.offspring_genome, + std::max(life.identity.born.value, last_expression[life.identity.organism]), 0, + life.account != LifeAccount{}}); + observe(life.identity.genome, life.identity.born.value); + } + for (const auto& corpse : corpses) { + const auto record = archive.organism(corpse.organism); + const auto expressed = archive.current_genome(corpse.organism); + if (!record || !expressed) + return false; + plans.push_back({corpse.life_id, *expressed, *expressed, corpse.offspring_genome, + std::max(record->born.value, last_expression[corpse.organism]), + corpse.died_tick, corpse.parent_life == 0}); + observe(record->genome, record->born.value); + observe(*expressed, record->born.value); + } + std::ranges::sort(plans, {}, &Plan::life); + std::set successors; + for (std::size_t index = 0; index < history.size(); ++index) { + const auto& revision = history[index]; + if (revision.tick == 0 || revision.tick > tick || revision.successor == revision.previous || + (index != 0 && (history[index - 1].tick > revision.tick || + (history[index - 1].tick == revision.tick && + history[index - 1].life >= revision.life))) || + !successors.insert(revision.successor).second) + return false; + const auto actor = std::ranges::lower_bound(plans, revision.life, {}, &Plan::life); + const auto parent = archive.find(revision.previous); + const auto child = archive.find(revision.successor); + if (actor == plans.end() || actor->life != revision.life || !actor->selectable || + actor->current != revision.previous || revision.tick <= actor->editable_after || + (actor->died != 0 && revision.tick >= actor->died) || !parent || !child || + child->parents().size() != 1 || child->parents().front() != revision.previous || + child->origin_event() != revision.successor || + child->schema_version() != parent->schema_version() || + child->development_version() != parent->development_version()) + return false; + actor->current = revision.successor; + // A plan selected here cannot have been expressed at an earlier birth. + const auto born = earliest_birth.find(revision.successor); + if (born != earliest_birth.end() && born->second < revision.tick) + return false; + } + for (const auto& plan : plans) { + const auto expressed = archive.find(plan.expressed); + const auto inherited = archive.find(plan.final); + if (plan.final == 0 || plan.current != plan.final || !expressed || !inherited || + expressed->schema_version() != inherited->schema_version() || + expressed->development_version() != inherited->development_version()) + return false; + } + return true; +} + std::expected validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame, const CellularLivesConfig& config, const NurseryConfig& nursery_config, @@ -284,7 +367,8 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame, accounting::Inventory nursery, accounting::Inventory heat, accounting::Inventory opening_total, bool detritus_rules = false, bool bud_rules = false, std::uint64_t next_bud_sequence = 1, - bool presence_rules = false, const CellularBoundaryLedger* boundary = nullptr) { + bool presence_rules = false, const CellularBoundaryLedger* boundary = nullptr, + const std::vector* plans = nullptr) { // A bud's identity lies in this region's namespace below the next sequence; anything // else is an allocated identity, below the namespace (ADR-0125). const auto bud_identity = [&](std::uint64_t identity) noexcept { @@ -350,6 +434,8 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame, (boundary ? boundary->nonresident_organisms.size() : 0)); for (std::size_t i = 0; i < lives.size(); ++i) { const auto& life = lives[i]; + if (!plans && life.offspring_genome != 0) + return std::unexpected{CellularLivesError::version}; // Founders are owned; buds are unowned wildlife (rules 4) and never earn offers. const bool wildlife = life.parent_life != 0; // ADR-0128: only owned lives leave; a lingering life is within its linger time. @@ -415,6 +501,8 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame, for (std::size_t i = 0; i < corpses.size(); ++i) { const auto& corpse = corpses[i]; + if (!plans && corpse.offspring_genome != 0) + return std::unexpected{CellularLivesError::version}; if (corpse.life_id == 0 || corpse.organism == 0 || corpse.source == 0 || corpse.died_tick == 0 || corpse.died_tick > config.tick || corpse.extent_um == 0 || (i != 0 && corpses[i - 1].organism >= corpse.organism) || @@ -451,6 +539,8 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame, if (std::ranges::adjacent_find(life_ids) != life_ids.end()) return std::unexpected{CellularLivesError::duplicate_life}; + if (plans && !validate_plans(lives, corpses, archive, *plans, config.tick)) + return std::unexpected{CellularLivesError::invalid_life}; const auto current = sum_state(nursery, heat, habitat, lives, corpses); if (!current) return std::unexpected{current.error()}; @@ -494,6 +584,7 @@ struct CellularLives::State { accounting::Inventory current_total{}; std::uint64_t next_bud_sequence{1}; // Format 5: the next bud identity's sequence. CellularBoundaryLedger boundary{}; + std::vector offspring_revisions; State(std::uint64_t world_id, std::uint64_t region_id, std::uint64_t frame_id, CellularLivesConfig cfg, NurseryConfig nursery_definition, @@ -730,6 +821,31 @@ std::span CellularLives::last_tick_feedback() co return last_tick_feedback_; } +std::span CellularLives::offspring_revisions() const noexcept { + return state_->offspring_revisions; +} +std::expected, CellularLivesError> +CellularLives::inheritance_upgrade_candidate() const { + if (state_->format_version != cellular_lives_migration_format || + state_->rules_version != cellular_lives_maturation_rules) + return std::unexpected{CellularLivesError::version}; + auto candidate = restore(snapshot(), world(), region(), frame(), tick()); + if (!candidate) + return std::unexpected(candidate.error()); + auto& next = *(*candidate)->state_; + next.format_version = cellular_lives_inheritance_format; + next.rules_version = cellular_lives_inheritance_rules; + for (auto& life : next.lives) + life.offspring_genome = life.identity.genome; + for (auto& corpse : next.corpses) { + const auto genome = next.archive.current_genome(corpse.organism); + if (!genome) + return std::unexpected{CellularLivesError::archive}; + corpse.offspring_genome = *genome; + } + return restore((*candidate)->snapshot(), world(), region(), frame(), tick()); +} + std::vector CellularLives::snapshot() const { const auto habitat = state_->habitat->snapshot(); const auto archive = state_->archive.encode(); @@ -738,29 +854,36 @@ std::vector CellularLives::snapshot() const { const auto corpse_count = state_->corpses.size(); const bool parents = state_->format_version >= cellular_lives_bud_format; const bool presence = state_->format_version >= cellular_lives_presence_format; - const auto life_bytes = state_->format_version == cellular_lives_legacy_format + const bool inheritance = state_->format_version == cellular_lives_inheritance_format; + const auto life_bytes = inheritance ? cellular_life_v6_bytes + 8 + : state_->format_version == cellular_lives_legacy_format ? cellular_life_v1_bytes : presence ? cellular_life_v6_bytes : parents ? cellular_life_v5_bytes : cellular_life_v2_bytes; const bool causes = state_->format_version >= cellular_lives_engulf_format; - const auto corpse_bytes = parents ? cellular_corpse_v5_bytes - : causes ? cellular_corpse_v4_bytes - : cellular_corpse_bytes; - const bool migration = state_->format_version == cellular_lives_migration_format; - const auto header_bytes = migration ? cellular_lives_v7_header_bytes - : parents ? cellular_lives_v5_header_bytes - : cellular_lives_header_bytes; + const auto corpse_bytes = inheritance ? cellular_corpse_v5_bytes + 8 + : parents ? cellular_corpse_v5_bytes + : causes ? cellular_corpse_v4_bytes + : cellular_corpse_bytes; + const bool migration = state_->format_version >= cellular_lives_migration_format; + const auto header_bytes = inheritance ? cellular_lives_v8_header_bytes + : migration ? cellular_lives_v7_header_bytes + : parents ? cellular_lives_v5_header_bytes + : cellular_lives_header_bytes; const auto external_count = migration ? state_->boundary.nonresident_organisms.size() : 0; - const auto total_bytes = header_bytes + cellular_site_bytes * site_count + - life_bytes * life_count + corpse_bytes * corpse_count + - habitat.size() + archive.size() + external_count * 8 + 8; + const auto total_bytes = + header_bytes + cellular_site_bytes * site_count + life_bytes * life_count + + corpse_bytes * corpse_count + habitat.size() + archive.size() + external_count * 8 + + state_->offspring_revisions.size() * cellular_offspring_revision_bytes + 8; if (total_bytes > max_cellular_lives_bytes || habitat.size() > biology::max_cellular_habitat_bytes || archive.size() > biology::max_archive_bytes || site_count > max_primitive_lives || life_count > biology::max_cellular_tick_lives || corpse_count > biology::max_archived_organisms || - external_count > biology::max_archived_organisms) + external_count > biology::max_archived_organisms || + state_->offspring_revisions.size() > biology::max_archived_genomes || + (!inheritance && !state_->offspring_revisions.empty())) throw std::length_error{"cellular lives checkpoint exceeds its format bounds"}; std::vector bytes; @@ -772,6 +895,7 @@ std::vector CellularLives::snapshot() const { : state_->format_version == cellular_lives_engulf_format ? cellular_lives_v4_magic : state_->format_version == cellular_lives_bud_format ? cellular_lives_v5_magic : state_->format_version == cellular_lives_presence_format ? cellular_lives_v6_magic + : inheritance ? cellular_lives_v8_magic : migration ? cellular_lives_v7_magic : cellular_lives_v2_magic; out.put(magic); @@ -802,6 +926,10 @@ std::vector CellularLives::snapshot() const { out.put(external_count, 4); out.put(0, 4); } + if (inheritance) { + out.put(state_->offspring_revisions.size(), 4); + out.put(0, 4); + } for (const auto site : state_->nursery_config.sites) out.site(site); for (const auto& life : state_->lives) { @@ -860,6 +988,8 @@ std::vector CellularLives::snapshot() const { out.zeros(7); out.put(life.frozen_since); } + if (inheritance) + out.put(life.offspring_genome); } for (const auto& corpse : state_->corpses) { out.put(corpse.life_id); @@ -879,12 +1009,21 @@ std::vector CellularLives::snapshot() const { } if (parents) out.put(corpse.parent_life); + if (inheritance) + out.put(corpse.offspring_genome); } out.raw(habitat); out.raw(archive); if (migration) for (const auto id : state_->boundary.nonresident_organisms) out.put(id); + if (inheritance) + for (const auto& revision : state_->offspring_revisions) { + out.put(revision.life); + out.put(revision.previous); + out.put(revision.successor); + out.put(revision.tick); + } if (bytes.size() + 8 != total_bytes) throw std::logic_error{"cellular lives checkpoint size calculation mismatch"}; out.put(checksum(bytes)); @@ -1057,6 +1196,8 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c auto lives = state_->lives; lives.push_back({request.account, allocation, state_->nursery_config.source, endowed->growth, *position, endowed->body, endowed->reserve}); + if (state_->format_version == cellular_lives_inheritance_format) + lives.back().offspring_genome = allocation.genome; std::ranges::sort(lives, {}, [](const CellularOwnedLife& life) { return life.identity.life; }); auto nursery_config = state_->nursery_config; @@ -1071,7 +1212,9 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c state_->rules_version >= cellular_lives_engulf_rules, state_->rules_version >= cellular_lives_bud_rules, state_->next_bud_sequence, state_->rules_version >= cellular_lives_presence_rules, - state_->format_version == cellular_lives_migration_format ? &state_->boundary : nullptr); + state_->format_version >= cellular_lives_migration_format ? &state_->boundary : nullptr, + state_->format_version == cellular_lives_inheritance_format ? &state_->offspring_revisions + : nullptr); if (!current) return std::unexpected{current.error()}; @@ -1082,6 +1225,7 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c state_->boundary)}}; candidate->last_tick_feedback_ = last_tick_feedback_; candidate->state_->next_bud_sequence = state_->next_bud_sequence; + candidate->state_->offspring_revisions = state_->offspring_revisions; return candidate; } @@ -1104,10 +1248,14 @@ CellularLives::restore(std::span bytes, std::uint64_t world, format_version == cellular_lives_format && rules_version == cellular_lives_rules; // Format 6 carries rules 5, 6 (founder 2) or 7 (founder 3, ADR-0137); no new state. - const bool migration_version = magic == cellular_lives_v7_magic && - format_version == cellular_lives_migration_format && - (rules_version == cellular_lives_foraging_rules || - rules_version == cellular_lives_maturation_rules); + const bool inheritance_version = magic == cellular_lives_v8_magic && + format_version == cellular_lives_inheritance_format && + rules_version == cellular_lives_inheritance_rules; + const bool migration_version = + inheritance_version || + (magic == cellular_lives_v7_magic && format_version == cellular_lives_migration_format && + (rules_version == cellular_lives_foraging_rules || + rules_version == cellular_lives_maturation_rules)); const bool presence_version = migration_version || (magic == cellular_lives_v6_magic && format_version == cellular_lives_presence_format && @@ -1132,6 +1280,8 @@ CellularLives::restore(std::span bytes, std::uint64_t world, return std::unexpected{CellularLivesError::version}; if (migration_version && bytes.size() < cellular_lives_v7_header_bytes + 8) return std::unexpected(CellularLivesError::format); + if (inheritance_version && bytes.size() < cellular_lives_v8_header_bytes + 8) + return std::unexpected(CellularLivesError::format); const auto saved_world = in.get(); const auto saved_region = in.get(); const auto saved_frame = in.get(); @@ -1171,19 +1321,29 @@ CellularLives::restore(std::span bytes, std::uint64_t world, if (in.get(4) != 0 || nonresident_count > biology::max_archived_organisms) return std::unexpected(CellularLivesError::format); } - const auto life_bytes = legacy ? cellular_life_v1_bytes - : presence_version ? cellular_life_v6_bytes - : bud_version ? cellular_life_v5_bytes - : cellular_life_v2_bytes; - const auto corpse_bytes = bud_version ? cellular_corpse_v5_bytes - : engulf_version ? cellular_corpse_v4_bytes - : cellular_corpse_bytes; - const auto expected_size = (migration_version ? cellular_lives_v7_header_bytes - : bud_version ? cellular_lives_v5_header_bytes - : cellular_lives_header_bytes) + + std::uint64_t plan_count = 0; + if (inheritance_version) { + plan_count = in.get(4); + if (in.get(4) != 0 || plan_count > biology::max_archived_genomes) + return std::unexpected{CellularLivesError::format}; + } + const auto life_bytes = inheritance_version ? cellular_life_v6_bytes + 8 + : legacy ? cellular_life_v1_bytes + : presence_version ? cellular_life_v6_bytes + : bud_version ? cellular_life_v5_bytes + : cellular_life_v2_bytes; + const auto corpse_bytes = inheritance_version ? cellular_corpse_v5_bytes + 8 + : bud_version ? cellular_corpse_v5_bytes + : engulf_version ? cellular_corpse_v4_bytes + : cellular_corpse_bytes; + const auto expected_size = (inheritance_version ? cellular_lives_v8_header_bytes + : migration_version ? cellular_lives_v7_header_bytes + : bud_version ? cellular_lives_v5_header_bytes + : cellular_lives_header_bytes) + cellular_site_bytes * site_count + life_bytes * life_count + corpse_bytes * corpse_count + habitat_size + archive_size + - nonresident_count * 8 + 8; + nonresident_count * 8 + + plan_count * cellular_offspring_revision_bytes + 8; if (source == 0 || next_bud_sequence == 0 || expected_size != bytes.size()) return std::unexpected{CellularLivesError::format}; @@ -1266,6 +1426,8 @@ CellularLives::restore(std::span bytes, std::uint64_t world, return std::unexpected{CellularLivesError::noncanonical}; life.presence = static_cast(presence); } + if (inheritance_version) + life.offspring_genome = in.get(); lives.push_back(life); } @@ -1298,6 +1460,8 @@ CellularLives::restore(std::span bytes, std::uint64_t world, } if (bud_version) corpse.parent_life = in.get(); + if (inheritance_version) + corpse.offspring_genome = in.get(); corpses.push_back(corpse); } const auto habitat_payload = in.raw(static_cast(habitat_size)); @@ -1331,6 +1495,10 @@ CellularLives::restore(std::span bytes, std::uint64_t world, for (std::uint64_t index = 0; index < nonresident_count; ++index) boundary.nonresident_organisms.push_back(in.get()); } + std::vector plan_history; + plan_history.reserve(static_cast(plan_count)); + for (std::uint64_t index = 0; index < plan_count; ++index) + plan_history.push_back({in.get(), in.get(), in.get(), in.get()}); if (archive->format_version() != (revision_version ? biology::lineage_archive_revision_format : biology::lineage_archive_format)) return std::unexpected{CellularLivesError::version}; @@ -1338,12 +1506,13 @@ CellularLives::restore(std::span bytes, std::uint64_t world, for (const auto& life : lives) { if (!life.mutation.offer) continue; - const auto genome = archive->find(life.identity.genome); + const auto genome = archive->find(cellular_offspring_genome(life)); if (!genome) return std::unexpected{CellularLivesError::archive}; const auto& offer = *life.mutation.offer; if (life.mutation.event_index == 0 || life.mutation.offer_tick == 0 || - life.mutation.offer_tick > saved_tick || offer.parent != life.identity.genome || + life.mutation.offer_tick > saved_tick || + offer.parent != cellular_offspring_genome(life) || offer.context.seed != mutation_seed(saved_world, saved_region, life.identity.life, life.mutation.event_index) || offer.context.stream != cellular_mutation_stream || @@ -1359,7 +1528,8 @@ CellularLives::restore(std::span bytes, std::uint64_t world, const auto current = validate_state( saved_world, saved_region, saved_frame, config, nursery_config, **habitat, lives, corpses, *archive, nursery, heat, opening_total, engulf_version, bud_version, next_bud_sequence, - presence_version, migration_version ? &boundary : nullptr); + presence_version, migration_version ? &boundary : nullptr, + inheritance_version ? &plan_history : nullptr); if (!current) return std::unexpected{current.error()}; @@ -1368,6 +1538,7 @@ CellularLives::restore(std::span bytes, std::uint64_t world, std::move(*habitat), std::move(lives), std::move(corpses), *archive, nursery, heat, opening_total, *current, format_version, rules_version, std::move(boundary))}}; restored->state_->next_bud_sequence = next_bud_sequence; + restored->state_->offspring_revisions = std::move(plan_history); if (!std::ranges::equal(bytes, restored->snapshot())) return std::unexpected{CellularLivesError::noncanonical}; return restored; @@ -1403,6 +1574,7 @@ CellularLives::advance_tick_with_mutations(std::span i const bool contact_rules = state_->rules_version >= cellular_lives_foraging_rules; const bool bud_rules = state_->rules_version >= cellular_lives_bud_rules; const bool presence_rules = state_->rules_version >= cellular_lives_presence_rules; + const bool inheritance_rules = state_->rules_version == cellular_lives_inheritance_rules; for (std::size_t i = 0; i < ordered.size(); ++i) { const auto& intent = ordered[i].intent; // Below rules 4 a bud is ignored, as engulfment is below rules 3 (ADR-0124/0125). @@ -1431,7 +1603,7 @@ CellularLives::advance_tick_with_mutations(std::span i if (!life->mutation.offer.has_value()) return std::unexpected{CellularLivesError::mutation}; const auto offer = life->mutation.offer.value_or(biology::MutationOffer{}); - if (offer.parent != life->identity.genome || + if (offer.parent != cellular_offspring_genome(*life) || offer.context.event_index != selection.event_index || (selection.operator_id != 0 && !std::ranges::any_of(offer.candidates, [&](const auto& candidate) { @@ -1481,6 +1653,7 @@ CellularLives::advance_tick_with_mutations(std::span i auto next_lives = state_->lives; auto next_corpses = state_->corpses; auto next_archive = state_->archive; + auto next_offspring_revisions = state_->offspring_revisions; auto next_heat = state_->heat; auto habitat_config = state_->habitat->config(); for (const auto& result : proposal->lives) { @@ -1514,7 +1687,7 @@ CellularLives::advance_tick_with_mutations(std::span i if (found->mutation.fed_energy_credit_pj >= threshold) { if (found->mutation.event_index == std::numeric_limits::max()) return std::unexpected{CellularLivesError::overflow}; - const auto genome = next_archive.find(found->identity.genome); + const auto genome = next_archive.find(cellular_offspring_genome(*found)); if (!genome) return std::unexpected{CellularLivesError::archive}; const auto next_event = found->mutation.event_index + 1; @@ -1549,11 +1722,11 @@ CellularLives::advance_tick_with_mutations(std::span i budget_for(next_archive, *found, state_->config.ambient_temperature_millikelvin); if (!corpse_budget) return std::unexpected{corpse_budget.error()}; - next_corpses.push_back({found->identity.life, found->identity.organism, found->source, - proposal->end_tick, dead.position, found->growth, - corpse_budget->phenotype.extent, dead.inventory, - engulf_rules ? dead.cause : biology::CellularDeathCause::unrecorded, - engulf_rules ? dead.predator_id : 0, found->parent_life}); + next_corpses.push_back( + {found->identity.life, found->identity.organism, found->source, proposal->end_tick, + dead.position, found->growth, corpse_budget->phenotype.extent, dead.inventory, + engulf_rules ? dead.cause : biology::CellularDeathCause::unrecorded, + engulf_rules ? dead.predator_id : 0, found->parent_life, found->offspring_genome}); next_lives.erase(found); } std::vector mutation_results; @@ -1567,7 +1740,7 @@ CellularLives::advance_tick_with_mutations(std::span i {selection.life_id, selection.successor_id, CellularMutationResult::life_died}); continue; } - const auto parent = next_archive.find(found->identity.genome); + const auto parent = next_archive.find(cellular_offspring_genome(*found)); if (!parent || !found->mutation.offer.has_value()) return std::unexpected{CellularLivesError::mutation}; if (selection.operator_id == 0) { @@ -1580,6 +1753,24 @@ CellularLives::advance_tick_with_mutations(std::span i continue; } const auto offer = found->mutation.offer.value_or(biology::MutationOffer{}); + if (inheritance_rules) { + const auto selected = + biology::select_mutation(*parent, offer.context, offer, selection.operator_id, + selection.successor_id, selection.successor_id); + if (!selected) + return std::unexpected{CellularLivesError::mutation}; + if (next_offspring_revisions.size() >= biology::max_archived_genomes || + !next_archive.admit(*selected)) + return std::unexpected{CellularLivesError::archive}; + next_offspring_revisions.push_back({selection.life_id, found->offspring_genome, + selection.successor_id, proposal->end_tick}); + found->offspring_genome = selection.successor_id; + found->mutation.offer.reset(); + found->mutation.offer_tick = 0; + mutation_results.push_back({selection.life_id, selection.successor_id, + CellularMutationResult::offspring_plan_applied}); + continue; + } auto transition = biology::fund_mutation_at_growth( *parent, offer.context, offer, selection.operator_id, selection.successor_id, selection.successor_id, found->reserve, @@ -1633,15 +1824,17 @@ CellularLives::advance_tick_with_mutations(std::span i if (state_->rules_version < cellular_lives_reproduction_rules) return false; const auto parent_genome = next_archive.find(parent->identity.genome); - if (!parent_genome) + const auto offspring_genome = next_archive.find(cellular_offspring_genome(*parent)); + if (!parent_genome || !offspring_genome) return false; const auto skill = parent_genome->parameter(biology::Capability::reproduction); // Twins split one whole bud: the parent must afford that whole bud first. return skill && cellular_twin_bud(state_->world, state_->region, request.life_id, proposal->end_tick, *skill) && - biology::fund_bud(*parent_genome, parent->growth, parent->reserve, - state_->config.ambient_temperature_millikelvin) + biology::fund_offspring(*parent_genome, *offspring_genome, parent->growth, + parent->reserve, + state_->config.ambient_temperature_millikelvin) .has_value(); }(); for (int copy = 0; copy < (twins ? 2 : 1); ++copy) { @@ -1652,12 +1845,13 @@ CellularLives::advance_tick_with_mutations(std::span i [](const CellularOwnedLife& value) { return value.identity.life; }); const bool twin = copy == 1; const auto temperature = state_->config.ambient_temperature_millikelvin; - const auto genome = next_archive.find(parent->identity.genome); + const auto genome = next_archive.find(cellular_offspring_genome(*parent)); + const auto expressed = next_archive.find(parent->identity.genome); const auto parent_budget = budget_for(next_archive, *parent, temperature); - if (!genome || !parent_budget) + if (!genome || !expressed || !parent_budget) return std::unexpected{CellularLivesError::archive}; - const auto transition = biology::fund_bud(*genome, parent->growth, parent->reserve, - temperature, twins ? 2U : 1U); + const auto transition = biology::fund_offspring( + *expressed, *genome, parent->growth, parent->reserve, temperature, twins ? 2U : 1U); if (!transition) { if (transition.error() == biology::BuddingError::development) return std::unexpected{CellularLivesError::biology}; @@ -1687,18 +1881,19 @@ CellularLives::advance_tick_with_mutations(std::span i break; } if (!add_inventory(next_heat, accounting::Inventory{transition->heat, {}}) || - !next_archive.record_birth(identity, parent->identity.genome, {proposal->end_tick})) + !next_archive.record_birth(identity, genome->id(), {proposal->end_tick})) return std::unexpected{CellularLivesError::archive}; parent->reserve = transition->parent_reserve; CellularOwnedLife bud{}; - bud.identity = { - identity, identity, parent->identity.genome, identity, {proposal->end_tick}}; + bud.identity = {identity, identity, genome->id(), identity, {proposal->end_tick}}; bud.source = parent->source; bud.growth = transition->growth; bud.position = **position; bud.body = transition->body; bud.reserve = transition->reserve; bud.parent_life = parent->identity.life; + if (inheritance_rules) + bud.offspring_genome = genome->id(); // Foreign residents can have a higher origin-region namespace. Keep // the sequence sorted even before the next parent's lookup/twin. const auto slot = std::ranges::lower_bound( @@ -1754,7 +1949,7 @@ CellularLives::advance_tick_with_mutations(std::span i // resuming from suspension did not take an active step and cannot grow here. // Expansion holds the existing lower corner fixed; earlier IDs claim space first. std::vector growth_results; - if (state_->rules_version == cellular_lives_maturation_rules) { + if (state_->rules_version >= cellular_lives_maturation_rules) { for (auto& life : next_lives) { const auto input = std::ranges::lower_bound(ordered, life.identity.life, {}, &CellularLifeIntent::life_id); @@ -1856,7 +2051,8 @@ CellularLives::advance_tick_with_mutations(std::span i state_->nursery_config, **next_habitat, next_lives, next_corpses, next_archive, state_->nursery, next_heat, state_->opening_total, engulf_rules, bud_rules, next_bud_sequence, presence_rules, - state_->format_version == cellular_lives_migration_format ? &state_->boundary : nullptr); + state_->format_version >= cellular_lives_migration_format ? &state_->boundary : nullptr, + inheritance_rules ? &next_offspring_revisions : nullptr); if (!total) return std::unexpected{total.error()}; @@ -1868,6 +2064,7 @@ CellularLives::advance_tick_with_mutations(std::span i std::move(next_corpses), next_archive, state_->nursery, next_heat, state_->opening_total, *total, state_->format_version, state_->rules_version, state_->boundary); next->next_bud_sequence = next_bud_sequence; + next->offspring_revisions = std::move(next_offspring_revisions); std::vector feedback; feedback.reserve(proposal->lives.size()); for (const auto& result : proposal->lives) { @@ -1910,7 +2107,7 @@ CellularLives::advance_tick_with_mutations(std::span i entry = std::prev(feedback.end()); } entry->presence = life.presence; - if (state_->rules_version == cellular_lives_maturation_rules) + if (state_->rules_version >= cellular_lives_maturation_rules) entry->reserve = life.reserve; // Includes funded growth/mutation/budding. entry->resume_blocked = std::ranges::find(resume_blocked, life.identity.life) != resume_blocked.end(); diff --git a/src/server/lifecycle/wildlife_controller.cpp b/src/server/lifecycle/wildlife_controller.cpp index 5a6fb94..3f34e30 100644 --- a/src/server/lifecycle/wildlife_controller.cpp +++ b/src/server/lifecycle/wildlife_controller.cpp @@ -109,8 +109,11 @@ wildlife_intents(const CellularLives& state, std::uint64_t tick) { if (!budget) return std::unexpected{CellularLivesError::biology}; biology::CellularStepIntent intent{}; + const auto offspring = state.archive().find(cellular_offspring_genome(life)); + if (!offspring) + return std::unexpected{CellularLivesError::archive}; if ((tick + life.identity.life) % wildlife_bud_interval_ticks == 0 && - biology::fund_bud(*genome, life.growth, life.reserve, temperature)) { + biology::fund_offspring(*genome, *offspring, life.growth, life.reserve, temperature)) { intent.bud = true; intents.push_back({life.identity.life, intent}); continue; diff --git a/tests/cellular_inheritance_tests.cpp b/tests/cellular_inheritance_tests.cpp new file mode 100644 index 0000000..5ba800e --- /dev/null +++ b/tests/cellular_inheritance_tests.cpp @@ -0,0 +1,346 @@ +#include "evo/server/lifecycle/cellular_census.hpp" +#include "evo/server/lifecycle/cellular_migration.hpp" +#include "fixtures/cellular_ecology.hpp" + +#include +#include + +namespace { +using namespace evo; +using namespace evo::server; +using namespace evo::fixture; +std::vector idle(const CellularLives& state, bool frozen = false, + bool bud = false, bool moving = false) { + std::vector result; + for (const auto& life : state.lives()) { + CellularLifeIntent input{life.identity.life, {}}; + if (life.account != LifeAccount{}) { + input.intent.frozen = frozen; + input.intent.bud = bud && !frozen; + if (moving && !frozen) + input.intent.movement = {1000, 0}; + } + result.push_back(input); + } + return result; +} +const CellularOwnedLife& parent(const CellularLives& state) { + const auto life = + std::ranges::find(state.lives(), 100, [](const auto& cell) { return cell.identity.life; }); + require(life != state.lives().end(), "inheritance parent missing"); + return *life; +} +void closed(const CellularLives& state) { + require(state.current_total() == state.opening_total(), "inheritance stock did not close"); +} +Owner initial() { + auto old = opening(7, true, 1); + require(!old->inheritance_upgrade_candidate(), "inheritance skipped prior versions"); + old = checked(old->migration_upgrade_candidate(), "boundary upgrade"); + require(!old->inheritance_upgrade_candidate(), "inheritance skipped maturation"); + old = checked(old->maturation_upgrade_candidate(), "maturation upgrade"); + const auto original = old->snapshot(); + auto state = checked(old->inheritance_upgrade_candidate(), "inheritance upgrade"); + require(old->snapshot() == original && state->tick() == old->tick() && + state->archive().encode() == old->archive().encode() && + state->current_total() == old->current_total() && + parent(*state).identity == parent(*old).identity && + parent(*state).body == parent(*old).body && + parent(*state).reserve == parent(*old).reserve && + parent(*state).offspring_genome == parent(*old).identity.genome && + state->offspring_revisions().empty(), + "upgrade changed biology"); + require(state->format_version() == 8 && state->rules_version() == 10 && + !state->inheritance_upgrade_candidate(), + "inheritance version boundary"); + require(restore(*state)->snapshot() == state->snapshot(), "initial inheritance restore"); + return state; +} +void choose_structure(Owner& state, std::uint64_t successor) { + for (unsigned tick = 0; tick < 60'000; ++tick) { + const auto before = parent(*state); + if (before.mutation.offer) { + const auto offer = *before.mutation.offer; + const auto found = std::ranges::find_if(offer.candidates, [](const auto& candidate) { + return candidate.target == biology::Capability::membrane || + candidate.target == biology::Capability::target_size; + }); + const bool selected = found != offer.candidates.end(); + const CellularMutationSelection selection{ + 100, before.mutation.event_index, before.mutation.offer_tick, successor, + selected ? found->operator_id : std::uint16_t{0}}; + // Stale and reused identities cannot spend a tick or consume the offer. + const auto bytes = state->snapshot(); + auto stale = selection; + ++stale.event_index; + require(!state->advance_tick_with_mutations(idle(*state), std::span{&stale, 1}) && + state->snapshot() == bytes, + "stale plan selection changed state"); + stale = selection; + stale.successor_id = before.identity.genome; + require(!state->advance_tick_with_mutations(idle(*state), std::span{&stale, 1}) && + state->snapshot() == bytes, + "reused plan identity changed state"); + auto control = restore(*state); + checked(control->advance_tick_with_mutations(idle(*control), {}), "unselected control"); + const auto result = + checked(state->advance_tick_with_mutations(idle(*state), std::span{&selection, 1}), + "plan selection tick"); + require(result.mutations.size() == 1 && + result.mutations.front().result == + (selected ? CellularMutationResult::offspring_plan_applied + : CellularMutationResult::declined), + "plan selection outcome"); + const auto& cell = parent(*state); + const auto& reference = parent(*control); + require(cell.identity == reference.identity && cell.body == reference.body && + cell.reserve == reference.reserve && cell.growth == reference.growth && + cell.position == reference.position && state->heat() == control->heat() && + state->nursery() == control->nursery() && + state->habitat().snapshot() == control->habitat().snapshot(), + "offspring selection rebuilt or charged the parent's body"); + if (selected) { + const auto& revision = state->offspring_revisions().back(); + require(cell.offspring_genome == successor && revision.life == 100 && + revision.previous == before.offspring_genome && + revision.successor == successor && revision.tick == state->tick() && + checked(state->archive().current_genome(100), "expressed archive") == + before.identity.genome && + checked(state->archive().living_carriers(successor), + "unborn carriers") == 0, + "offspring plan mistaken for an expressed organism"); + require(restore(*state)->snapshot() == state->snapshot(), "selected plan restore"); + closed(*state); + return; + } + } else + checked(state->advance_tick_with_mutations(idle(*state), {}), "earned offer tick"); + closed(*state); + } + throw std::runtime_error("finite feeding never earned a structural offspring choice"); +} +std::uint64_t bud(Owner& state) { + for (unsigned tick = 0; tick < 30'000; ++tick) { + const auto plan = parent(*state).offspring_genome; + const auto result = + checked(state->advance_tick_with_mutations(idle(*state, false, true), {}), + "inherited bud tick"); + closed(*state); + for (const auto& outcome : result.buds) { + if (outcome.parent_life != 100 || outcome.result != CellularBudResult::budded) + continue; + const auto child = + std::ranges::find(state->lives(), outcome.bud_life, + [](const auto& life) { return life.identity.life; }); + require(child != state->lives().end() && child->identity.genome == plan && + child->offspring_genome == plan && child->parent_life == 100 && + child->account == LifeAccount{} && + std::ranges::none_of(result.growth, + [&](const auto& growth) { + return growth.life_id == child->identity.life; + }), + "newborn plan/body identity or phase"); + const auto genome = checked(state->archive().find(plan), "inherited genome"); + require(checked(biology::metabolic_budget(genome, child->growth, {293150, {}}), + "inherited body") + .body == child->body, + "child body uses parent genome"); + return child->identity.life; + } + } + throw std::runtime_error("finite parent never funded inherited offspring"); +} +Owner family() { + auto state = initial(); + choose_structure(state, 1'000'000); + bud(state); + return state; +} +void continuation(CellularLives& state) { + bool maintained = false; + const auto plan = parent(state).offspring_genome; + const auto history = state.offspring_revisions().size(); + for (unsigned tick = 0; tick < 64; ++tick) { + checked(state.advance_tick_with_mutations(idle(state, true), {}), "inherited continuation"); + for (const auto& feedback : state.last_tick_feedback()) + if (feedback.life_id != 100) + maintained |= feedback.maintenance_cost.value > 0; + require(parent(state).offspring_genome == plan && + state.offspring_revisions().size() == history, + "continuation lost retained plan"); + closed(state); + } + // Maximal funded birth can already be fully grown; maintenance must still run. + require(maintained, "inherited continuation skipped offspring metabolism"); +} +void put(std::vector& bytes, std::size_t at, std::uint64_t value, + unsigned width = 8) { + for (unsigned offset = 0; offset < width; ++offset) + bytes.at(at + offset) = static_cast(value >> (offset * 8U)); +} +void reseal(std::vector& bytes) { + std::uint64_t value = 14695981039346656037ULL; + for (const auto byte : std::span{bytes}.first(bytes.size() - 8)) + value = (value ^ byte) * 1099511628211ULL; + put(bytes, bytes.size() - 8, value); +} +void codecs_and_siblings() { + auto state = family(); + const auto first_child = std::ranges::find_if( + state->lives(), [](const auto& life) { return life.parent_life == 100; }); + require(first_child != state->lives().end(), "missing first child"); + const auto old_child = first_child->identity; + const auto bytes = state->snapshot(); + const auto history = bytes.size() - 8 - state->offspring_revisions().size() * 32; + // One founding site, owner-8 header, then life rows. All corruptions carry a + // valid outer checksum; restore must establish biological/history semantics. + const auto corrupt = [&](std::size_t at, std::uint64_t value, unsigned width = 8) { + auto altered = bytes; + put(altered, at, value, width); + reseal(altered); + require(!CellularLives::restore(altered, state->world(), state->region(), state->frame(), + state->tick()), + "forged inherited checkpoint accepted"); + }; + corrupt(316 + 8 + 504, 0); + corrupt(316 + 8 + 504, 100); + corrupt(316 + 8 + 504, 999'999); + corrupt(history, old_child.life); + corrupt(history + 8, 999'999); + corrupt(history + 16, 100); + corrupt(history + 24, state->tick() + 1); + corrupt(308, 0xFFFF'FFFFULL, 4); + corrupt(312, 1, 4); + corrupt(12, 9, 4); + auto flipped = bytes; + flipped.at(316) ^= 1; + require(!CellularLives::restore(flipped, state->world(), state->region(), state->frame(), + state->tick()), + "checksum damage accepted"); + require(!CellularPopulation::create(restore(*state)) && !CellularCensus::observe(*state) && + !CellularMigration::prepare(*state, *state, 100), + "unsupported old adapter admitted plans"); + CellularBatch old_trace; + old_trace.header = {state->world(), state->region(), state->frame(), {}, {}, + state->tick(), state->tick() + 1}; + old_trace.header.predecessor.fill(1); + old_trace.header.predecessor_digest.fill(2); + old_trace.ticks.push_back({idle(*state), {}, {}}); + const auto encoded = checked(encode_cellular_batch(old_trace), "encode valid old trace"); + const auto decoded = checked(decode_cellular_batch(encoded), "decode valid old trace"); + const auto replayed = replay_cellular_batch(*state, decoded); + if (replayed) + throw std::runtime_error("old replay admitted inherited owner"); + require(replayed.error() == CellularBatchError::version, + "old replay refused for a reason other than version admission"); + choose_structure(state, 1'000'001); + require(state->offspring_revisions().size() == 2 && parent(*state).identity.genome == 100, + "later plan lost earlier history or changed parent"); + require(checked(state->archive().organism(old_child.organism), "older child archive").genome == + old_child.genome, + "later plan rewrote earlier child's birth"); + state = restore(*state); + bud(state); + state = restore(*state); + bud(state); + require(parent(*state).offspring_genome == 1'000'001 && + state->offspring_revisions().size() == 2, + "sibling birth reset selected plan"); + const auto frozen = parent(*state); + for (unsigned tick = 0; tick < 250; ++tick) + checked(state->advance_tick_with_mutations(idle(*state, true), {}), "frozen inheritance"); + const auto after = parent(*state); + require(after.presence == CellularPresence::suspended && after.body == frozen.body && + after.reserve == frozen.reserve && after.growth == frozen.growth && + after.mutation == frozen.mutation && + after.offspring_genome == frozen.offspring_genome, + "offline parent progressed its plan or biology"); + require(restore(*state)->snapshot() == state->snapshot(), "suspended plan restore"); +} +void legacy_expression_upgrade() { + auto state = opening(7, true, 1); + state = checked(state->migration_upgrade_candidate(), "legacy boundary upgrade"); + state = checked(state->maturation_upgrade_candidate(), "legacy maturation upgrade"); + bool expressed = false; + for (unsigned tick = 0; tick < 60'000 && !expressed; ++tick) { + const auto before = parent(*state); + if (!before.mutation.offer) { + checked(state->advance_tick_with_mutations(idle(*state), {}), "legacy earned offer"); + continue; + } + const CellularMutationSelection selection{ + 100, before.mutation.event_index, before.mutation.offer_tick, 900'000, + before.mutation.offer->candidates.front().operator_id}; + const auto result = + checked(state->advance_tick_with_mutations(idle(*state), std::span{&selection, 1}), + "legacy expression"); + expressed = result.mutations.front().result == CellularMutationResult::applied; + } + require(expressed && parent(*state).identity.genome == 900'000, + "legacy mutation was not expressed"); + const auto at = state->archive().revisions().back().at.value; + const auto archive = state->archive().encode(); + state = checked(state->inheritance_upgrade_candidate(), "expressed parent upgrade"); + require(state->archive().encode() == archive && parent(*state).offspring_genome == 900'000, + "upgrade lost expressed revision"); + choose_structure(state, 1'000'000); + auto forged = state->snapshot(); + put(forged, forged.size() - 8 - 32 + 24, at); + reseal(forged); + require(!CellularLives::restore(forged, state->world(), state->region(), state->frame(), + state->tick()), + "plan selected before its expressed baseline existed"); +} +void death_history() { + auto state = family(); + for (unsigned tick = 0; tick < 100'000; ++tick) { + checked(state->advance_tick_with_mutations(idle(*state, false, false, true), {}), + "parent ecological death"); + closed(*state); + const auto corpse = std::ranges::find(state->corpses(), 100, &CellularOwnedCorpse::life_id); + if (corpse != state->corpses().end()) { + require(corpse->offspring_genome == 1'000'000 && + state->offspring_revisions().size() == 1, + "death discarded selected plan history"); + require(restore(*state)->snapshot() == state->snapshot(), "dead-plan history restore"); + return; + } + } + throw std::runtime_error("finite parent did not die after leaving food"); +} +void save(const char* path, std::span bytes) { + std::ofstream file(path, std::ios::binary | std::ios::trunc); + file.write(reinterpret_cast(bytes.data()), + static_cast(bytes.size())); + require(file.good(), "inheritance checkpoint write"); +} +} // namespace +int main(int argc, char** argv) try { + if (argc == 4 && std::string_view{argv[1]} == "--checkpoint") { + auto state = family(); + save(argv[2], state->snapshot()); + continuation(*state); + save(argv[3], state->snapshot()); + return 0; + } + if (argc == 4 && std::string_view{argv[1]} == "--resume") { + std::ifstream file(argv[2], std::ios::binary); + const std::vector bytes{std::istreambuf_iterator{file}, {}}; + require(bytes.size() >= 324, "inheritance checkpoint length"); + std::uint64_t tick = 0; + for (unsigned offset = 0; offset < 8; ++offset) + tick |= std::uint64_t{bytes[40 + offset]} << (offset * 8U); + auto state = checked(CellularLives::restore(bytes, 207, 1, 1, tick), "new-process plans"); + continuation(*state); + save(argv[3], state->snapshot()); + return 0; + } + require(argc == 1, "unknown inheritance arguments"); + codecs_and_siblings(); + legacy_expression_upgrade(); + death_history(); + return 0; +} catch (const std::exception& error) { + std::cerr << error.what() << '\n'; + return 1; +}