diff --git a/CMakeLists.txt b/CMakeLists.txt index 38fd540..0b5b313 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -80,7 +80,7 @@ evo_owned_target(evo_biology) # M11.2 portable lifecycle orchestration; no dependency from the foundation proof. add_library(evo_lifecycle STATIC src/server/lifecycle/primitive_lives.cpp - src/server/lifecycle/primitive_batch.cpp) + src/server/lifecycle/primitive_batch.cpp src/server/lifecycle/cellular_lives.cpp) add_library(evo::lifecycle ALIAS evo_lifecycle) target_link_libraries(evo_lifecycle PUBLIC evo::biology) evo_owned_target(evo_lifecycle) @@ -455,6 +455,11 @@ if(BUILD_TESTING) target_link_libraries(evo-primitive-lives-tests PRIVATE evo::lifecycle) evo_owned_target(evo-primitive-lives-tests) add_test(NAME primitive-lives COMMAND evo-primitive-lives-tests) + add_executable(evo-cellular-lives-tests tests/cellular_lives_tests.cpp) + target_link_libraries(evo-cellular-lives-tests PRIVATE evo::lifecycle) + evo_owned_target(evo-cellular-lives-tests) + add_test(NAME cellular-lives-owner COMMAND evo-cellular-lives-tests) + set_tests_properties(cellular-lives-owner PROPERTIES TIMEOUT 60) target_link_libraries(evo-metabolism-tests PRIVATE evo::processes) evo_owned_target(evo-metabolism-tests) add_test(NAME metabolism-contracts COMMAND evo-metabolism-tests) diff --git a/README.md b/README.md index fbce6d5..b2e3bcd 100644 --- a/README.md +++ b/README.md @@ -124,12 +124,15 @@ producer, feeding, reproduction and episode fixtures built on that ledger; they are bounded experiments, not organism biology. `src/biology` holds the immutable genome record, the deterministic development that derives a phenotype from it and the metabolic budgets that give capability a cost, and the seeded mutation -catalog that proposes successors and the archive that keeps them. No fixture reads -a genome yet. +catalog that proposes successors and the archive that keeps them. Synthetic +process fixtures remain separate from organism biology. `apps/evo-sim` owns CLI/file I/O and reporting. `tests` holds contract, -fuzz and measurement programs. Future biology, world, networking and persistence -modules are documented boundaries; they are added when they have real behavior. +fuzz and measurement programs. `src/server/lifecycle` owns funded primitive +founder creation and an in-memory cellular tick owner over the finite habitat. +The cellular owner is not yet wired to durable profile-4 recovery or session +intentions, so it is not a playable client path. `evo::simulation` remains +graphics-, network- and database-independent. World0 is persistent state. No normal configure, build, test or CI job may create, reset, deploy to or delete it. Gitea builds the proof image for Harbor; a bounded diff --git a/docs/engineering/M11_3_DELIVERY_PLAN.md b/docs/engineering/M11_3_DELIVERY_PLAN.md index afa1826..d2ed7ca 100644 --- a/docs/engineering/M11_3_DELIVERY_PLAN.md +++ b/docs/engineering/M11_3_DELIVERY_PLAN.md @@ -151,6 +151,10 @@ scoped change before starting the next segment. - 11.3c-5: ADR-0107 closes unaffordable maintenance in the same tick, moving body and reserve into a corpse candidate and accumulated heat to an explicit output. The durable heat owner and lineage/checkpoint publication remain open. +- 11.3c-6: `server::CellularLives` adopts funded profile-3 founders into one + in-memory cellular owner, applies shared-habitat ticks atomically, records + starvation corpses/deaths and enforces region-wide conservation. Checkpoint + encoding, durable publication and online session execution remain open. - 11.3d contract: ADR-0108/0109 and `schemas/cellular-lives-v1.md` define a separate profile-4 checkpoint closure for lives, habitat, corpses, heat and lineage. No profile-4 code or durable tick publication is implemented yet. diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index fd293ae..916a939 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -6028,3 +6028,21 @@ profile 3. This is documentation only; no codec, SQL admission or recovery behavior is implemented or validated by this entry. `git diff --check` is the applicable local check. Profile-4 code, PostgreSQL CI and crash/restart tests remain required. + +## 2026-10-10 — M11.3c-6 in-memory cellular owner (CI pending) + +Added `server::CellularLives` as a portable lifecycle owner over funded +profile-3 opening state. It derives each life budget from its archived genome, +advances a complete stable-ID intention set against one shared habitat, and +atomically applies living results, death records, corpses, heat and patch stock +only when the region-wide totals still reconcile. The focused test covers +contested intake, a late invalid intention with no partial advance, and both +founders reaching terminal death while retaining complete lineage and inventory. + +Executed locally: direct warning-as-error MSVC 19.44 Debug and Release/NDEBUG +compile/run; Debug CTest `cellular-lives-owner` (1/1 passed); CMake configure and +generation registered the target; and `git diff --check`. The CMake/Ninja build +idled without starting a compiler, so the focused target was compiled directly. +`clang-format` and `clang-tidy` are unavailable on this Windows PATH. Linux +sanitizer/CI, profile-4 codec/restore, durable publication and session wiring +remain pending. diff --git a/include/evo/server/lifecycle/cellular_lives.hpp b/include/evo/server/lifecycle/cellular_lives.hpp new file mode 100644 index 0000000..acdd576 --- /dev/null +++ b/include/evo/server/lifecycle/cellular_lives.hpp @@ -0,0 +1,94 @@ +#pragma once + +#include "evo/biology/cellular_region_step.hpp" +#include "evo/server/lifecycle/primitive_lives.hpp" + +#include +#include +#include +#include +#include +#include + +namespace evo::server { +struct CellularOwnedLife { + LifeAccount account{}; + LifeAllocation identity{}; + std::uint64_t source{}; + biology::GrowthState growth{}; + biology::CellularPosition position{}; + accounting::Inventory body{}; + accounting::Inventory reserve{}; + auto operator<=>(const CellularOwnedLife&) const = default; +}; +struct CellularOwnedCorpse { + std::uint64_t organism{}; + std::uint64_t died_tick{}; + biology::CellularPosition position{}; + accounting::Inventory inventory{}; + auto operator<=>(const CellularOwnedCorpse&) const = default; +}; +struct CellularLifeIntent { + std::uint64_t life_id{}; + biology::CellularStepIntent intent{}; + auto operator<=>(const CellularLifeIntent&) const = default; +}; +struct CellularLivesConfig { + biology::CellularArea area{}; + std::uint64_t tick{}; + std::uint32_t ambient_temperature_millikelvin{}; +}; +enum class CellularLivesError : std::uint8_t { + identity, + invalid_config, + invalid_life, + duplicate_life, + invalid_tick, + invalid_intents, + biology, + region_step, + archive, + habitat, + overflow, + conservation +}; + +// In-memory authoritative cellular owner. It consumes funded profile-3 opening +// state but never mutates or reinterprets that checkpoint. Each tick is applied +// to a detached candidate and swapped only after life, corpse, heat, habitat and +// archive closure all validate. Durable profile-4 publication remains external. +class CellularLives { + public: + [[nodiscard]] static std::expected, CellularLivesError> + create(const PrimitiveLives& opening, std::unique_ptr habitat, + CellularLivesConfig config); + CellularLives(const CellularLives&) = delete; + CellularLives& operator=(const CellularLives&) = delete; + ~CellularLives(); + + [[nodiscard]] std::uint64_t world() const noexcept; + [[nodiscard]] std::uint64_t region() const noexcept; + [[nodiscard]] std::uint64_t frame() const noexcept; + [[nodiscard]] std::uint64_t tick() const noexcept; + [[nodiscard]] biology::CellularArea area() const noexcept; + [[nodiscard]] std::span lives() const noexcept; + [[nodiscard]] std::span corpses() const noexcept; + [[nodiscard]] const biology::CellularHabitat& habitat() const noexcept; + [[nodiscard]] const biology::LineageArchive& archive() const noexcept; + [[nodiscard]] accounting::Inventory nursery() const noexcept; + [[nodiscard]] accounting::Inventory heat() const noexcept; + [[nodiscard]] accounting::Inventory opening_total() const noexcept; + [[nodiscard]] accounting::Inventory current_total() const noexcept; + + // Advances every living cell exactly one 50 ms tick. Intentions are keyed by + // stable life ID and must cover the living set exactly. Any refusal leaves + // this owner byte-for-byte unchanged. + [[nodiscard]] std::expected + advance_tick(std::span intents); + + private: + struct State; + explicit CellularLives(std::unique_ptr state); + std::unique_ptr state_; +}; +} // namespace evo::server diff --git a/src/server/lifecycle/cellular_lives.cpp b/src/server/lifecycle/cellular_lives.cpp new file mode 100644 index 0000000..f4f565f --- /dev/null +++ b/src/server/lifecycle/cellular_lives.cpp @@ -0,0 +1,266 @@ +#include "evo/server/lifecycle/cellular_lives.hpp" + +#include +#include +#include + +namespace evo::server { +namespace { +bool add_inventory(accounting::Inventory& total, const accounting::Inventory& value) noexcept { + constexpr auto maximum = std::numeric_limits::max(); + if (value.energy.value > maximum - total.energy.value) + return false; + for (std::size_t channel = 0; channel < total.matter.size(); ++channel) + if (value.matter[channel].value > maximum - total.matter[channel].value) + return false; + total.energy.value += value.energy.value; + for (std::size_t channel = 0; channel < total.matter.size(); ++channel) + total.matter[channel].value += value.matter[channel].value; + return true; +} + +std::expected +budget_for(const biology::LineageArchive& archive, const CellularOwnedLife& life, + std::uint32_t temperature) { + const auto genome = archive.find(life.identity.genome); + if (!genome) + return std::unexpected{CellularLivesError::archive}; + const auto budget = biology::metabolic_budget(*genome, life.growth, {temperature, {}}); + if (!budget) + return std::unexpected{CellularLivesError::biology}; + return *budget; +} + +std::expected +sum_state(accounting::Inventory nursery, accounting::Inventory heat, + const biology::CellularHabitat& habitat, std::span lives, + std::span corpses) noexcept { + auto total = nursery; + if (!add_inventory(total, heat)) + return std::unexpected{CellularLivesError::overflow}; + if (!add_inventory(total, habitat.totals())) + return std::unexpected{CellularLivesError::overflow}; + for (const auto& life : lives) + if (!add_inventory(total, life.body) || !add_inventory(total, life.reserve)) + return std::unexpected{CellularLivesError::overflow}; + for (const auto& corpse : corpses) + if (!add_inventory(total, corpse.inventory)) + return std::unexpected{CellularLivesError::overflow}; + return total; +} +} // namespace + +struct CellularLives::State { + std::uint64_t world{}, region{}, frame{}; + CellularLivesConfig config{}; + std::unique_ptr habitat; + std::vector lives; + std::vector corpses; + biology::LineageArchive archive; + accounting::Inventory nursery{}; + accounting::Inventory heat{}; + accounting::Inventory opening_total{}; + accounting::Inventory current_total{}; + + State(std::uint64_t world_id, std::uint64_t region_id, std::uint64_t frame_id, + CellularLivesConfig cfg, std::unique_ptr map, + std::vector living, std::vector dead, + const biology::LineageArchive& history, accounting::Inventory source, + accounting::Inventory accumulated_heat, accounting::Inventory initial, + accounting::Inventory current) + : world{world_id}, region{region_id}, frame{frame_id}, config{cfg}, + habitat{std::move(map)}, lives{std::move(living)}, corpses{std::move(dead)}, + archive{history}, nursery{source}, heat{accumulated_heat}, opening_total{initial}, + current_total{current} {} +}; + +CellularLives::CellularLives(std::unique_ptr state) : state_{std::move(state)} {} +CellularLives::~CellularLives() = default; + +std::expected, CellularLivesError> +CellularLives::create(const PrimitiveLives& opening, + std::unique_ptr habitat, + CellularLivesConfig config) { + if (!habitat) + return std::unexpected{CellularLivesError::invalid_config}; + const auto& nursery_config = opening.config(); + const auto& map = habitat->config(); + if (nursery_config.world == 0 || nursery_config.region == 0 || nursery_config.frame == 0 || + map.world != nursery_config.world || map.region != nursery_config.region || + map.frame != nursery_config.frame || config.area.width_um == 0 || + config.area.height_um == 0 || config.area.width_um != map.width_um || + config.area.height_um != map.height_um || config.ambient_temperature_millikelvin == 0 || + opening.lives().size() > biology::max_cellular_tick_lives || + opening.balances().size() != 2 + 2 * nursery_config.sites.size()) + return std::unexpected{CellularLivesError::invalid_config}; + + std::vector lives; + lives.reserve(opening.lives().size()); + for (const auto& primitive : opening.lives()) { + if (primitive.identity.born.value == 0 || primitive.identity.born.value > config.tick || + primitive.identity.life == 0 || primitive.identity.organism == 0 || + primitive.identity.genome == 0 || primitive.source == 0 || + primitive.site.x_um < 0 || primitive.site.y_um < 0) + return std::unexpected{CellularLivesError::invalid_life}; + if (primitive.body.value == 0 || primitive.reserve.value == 0) + return std::unexpected{CellularLivesError::invalid_life}; + const auto body_index = static_cast(primitive.body.value - 1); + const auto reserve_index = static_cast(primitive.reserve.value - 1); + if (body_index >= opening.balances().size() || reserve_index >= opening.balances().size()) + return std::unexpected{CellularLivesError::invalid_life}; + lives.push_back({primitive.request.account, + primitive.identity, + primitive.source, + primitive.growth, + {static_cast(primitive.site.x_um), + static_cast(primitive.site.y_um)}, + opening.balances()[body_index], + opening.balances()[reserve_index]}); + } + std::ranges::sort(lives, {}, [](const auto& life) { return life.identity.life; }); + for (std::size_t i = 0; i < lives.size(); ++i) { + const auto& life = lives[i]; + if (i != 0 && lives[i - 1].identity.life == life.identity.life) + return std::unexpected{CellularLivesError::duplicate_life}; + const auto budget = budget_for(opening.archive(), life, + config.ambient_temperature_millikelvin); + if (!budget || budget->phenotype.extent == 0 || + budget->phenotype.extent > config.area.width_um || + budget->phenotype.extent > config.area.height_um || life.body.energy.value != 0 || + budget->body != life.body || + life.position.x_um > config.area.width_um - budget->phenotype.extent || + life.position.y_um > config.area.height_um - budget->phenotype.extent) + return std::unexpected{CellularLivesError::invalid_life}; + } + auto initial_total = opening.totals(); + if (!add_inventory(initial_total, habitat->totals())) + return std::unexpected{CellularLivesError::overflow}; + const auto nursery = opening.balances()[0]; + const auto heat = opening.balances()[1]; + const auto current = sum_state(nursery, heat, *habitat, lives, {}); + if (!current) + return std::unexpected{current.error()}; + if (*current != initial_total) + return std::unexpected{CellularLivesError::conservation}; + + auto state = std::make_unique( + nursery_config.world, nursery_config.region, nursery_config.frame, config, + std::move(habitat), std::move(lives), std::vector{}, + opening.archive(), nursery, heat, initial_total, *current); + return std::unique_ptr{new CellularLives{std::move(state)}}; +} + +std::uint64_t CellularLives::world() const noexcept { return state_->world; } +std::uint64_t CellularLives::region() const noexcept { return state_->region; } +std::uint64_t CellularLives::frame() const noexcept { return state_->frame; } +std::uint64_t CellularLives::tick() const noexcept { return state_->config.tick; } +biology::CellularArea CellularLives::area() const noexcept { return state_->config.area; } +std::span CellularLives::lives() const noexcept { return state_->lives; } +std::span CellularLives::corpses() const noexcept { + return state_->corpses; +} +const biology::CellularHabitat& CellularLives::habitat() const noexcept { return *state_->habitat; } +const biology::LineageArchive& CellularLives::archive() const noexcept { return state_->archive; } +accounting::Inventory CellularLives::nursery() const noexcept { return state_->nursery; } +accounting::Inventory CellularLives::heat() const noexcept { return state_->heat; } +accounting::Inventory CellularLives::opening_total() const noexcept { + return state_->opening_total; +} +accounting::Inventory CellularLives::current_total() const noexcept { + return state_->current_total; +} + +std::expected +CellularLives::advance_tick(std::span intents) { + if (state_->config.tick == std::numeric_limits::max()) + return std::unexpected{CellularLivesError::invalid_tick}; + if (intents.size() != state_->lives.size()) + return std::unexpected{CellularLivesError::invalid_intents}; + std::vector ordered{intents.begin(), intents.end()}; + std::ranges::sort(ordered, {}, &CellularLifeIntent::life_id); + for (std::size_t i = 0; i < ordered.size(); ++i) + if ((i != 0 && ordered[i - 1].life_id == ordered[i].life_id) || + ordered[i].life_id != state_->lives[i].identity.life) + return std::unexpected{CellularLivesError::invalid_intents}; + + std::vector inputs; + inputs.reserve(state_->lives.size()); + for (std::size_t i = 0; i < state_->lives.size(); ++i) { + const auto& life = state_->lives[i]; + const auto budget = budget_for(state_->archive, life, + state_->config.ambient_temperature_millikelvin); + if (!budget) + return std::unexpected{budget.error()}; + inputs.push_back({life.identity.life, + life.position, + budget->phenotype.extent, + ordered[i].intent, + life.body, + life.reserve, + {}, + *budget}); + } + auto proposal = biology::propose_cellular_region_step(state_->config.tick, state_->config.area, + inputs, *state_->habitat); + if (!proposal) + return std::unexpected{CellularLivesError::region_step}; + + auto next_lives = state_->lives; + auto next_corpses = state_->corpses; + auto next_archive = state_->archive; + auto next_heat = state_->heat; + auto habitat_config = state_->habitat->config(); + for (const auto& result : proposal->lives) { + const auto found = std::ranges::lower_bound( + next_lives, result.life_id, {}, [](const auto& life) { return life.identity.life; }); + if (found == next_lives.end() || found->identity.life != result.life_id) + return std::unexpected{CellularLivesError::invalid_life}; + found->position = result.candidate.position; + found->reserve = result.candidate.reserve_after; + if (!add_inventory(next_heat, result.candidate.heat_after)) + return std::unexpected{CellularLivesError::overflow}; + } + for (const auto& dead : proposal->starved) { + const auto found = std::ranges::lower_bound( + next_lives, dead.life_id, {}, [](const auto& life) { return life.identity.life; }); + if (found == next_lives.end() || found->identity.life != dead.life_id || + !next_archive.record_death(found->identity.organism, {proposal->end_tick})) + return std::unexpected{CellularLivesError::archive}; + next_corpses.push_back( + {found->identity.organism, proposal->end_tick, dead.position, dead.inventory}); + next_lives.erase(found); + } + std::ranges::sort(next_corpses, {}, &CellularOwnedCorpse::organism); + if (proposal->heat_released.value > + std::numeric_limits::max() - next_heat.energy.value) + return std::unexpected{CellularLivesError::overflow}; + next_heat.energy.value += proposal->heat_released.value; + for (const auto& update : proposal->patches) { + const auto found = std::ranges::lower_bound( + habitat_config.patches, update.address, {}, [](const auto& patch) { + return patch.address; + }); + if (found == habitat_config.patches.end() || found->address != update.address) + return std::unexpected{CellularLivesError::habitat}; + found->stock = update.stock; + } + auto next_habitat = biology::CellularHabitat::create(std::move(habitat_config)); + if (!next_habitat) + return std::unexpected{CellularLivesError::habitat}; + const auto total = sum_state(state_->nursery, next_heat, **next_habitat, next_lives, + next_corpses); + if (!total) + return std::unexpected{total.error()}; + if (*total != state_->opening_total) + return std::unexpected{CellularLivesError::conservation}; + + auto next = std::make_unique( + state_->world, state_->region, state_->frame, + CellularLivesConfig{state_->config.area, proposal->end_tick, + state_->config.ambient_temperature_millikelvin}, + std::move(*next_habitat), std::move(next_lives), std::move(next_corpses), next_archive, + state_->nursery, next_heat, state_->opening_total, *total); + state_.swap(next); + return std::move(*proposal); +} +} // namespace evo::server diff --git a/tests/cellular_lives_tests.cpp b/tests/cellular_lives_tests.cpp new file mode 100644 index 0000000..5438b7c --- /dev/null +++ b/tests/cellular_lives_tests.cpp @@ -0,0 +1,105 @@ +#include "evo/server/lifecycle/cellular_lives.hpp" + +#include +#include +#include +#include +#include + +namespace { +using namespace evo::server; +using evo::accounting::Inventory; + +void check(bool value, std::source_location at = std::source_location::current()) { + if (!value) + throw std::runtime_error("cellular lives line " + std::to_string(at.line())); +} +#define CHECK(...) check(static_cast(__VA_ARGS__)) + +Inventory founder_price(std::uint64_t count) { + const auto endowment = evo::biology::primitive_endowment(); + CHECK(endowment); + auto funding = endowment->body; + funding.energy.value = endowment->reserve.energy.value + endowment->construction.value; + funding.energy.value *= count; + for (auto& channel : funding.matter) + channel.value *= count; + return funding; +} + +void owner_advances_and_closes_death_atomically() { + auto primitive = PrimitiveLives::create({90, 1, 7, 17, founder_price(2), {{0, 0}, {20, 0}}}); + CHECK(primitive); + LifeRequest request{}; + request.account.back() = 1; + request.action = 1; + CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}})); + request.account.back() = 2; + CHECK((*primitive)->spawn(request, {2, 102, 202, 302, {1}})); + + evo::biology::CellularHabitatConfig habitat_config{ + 90, 1, 7, 3'000, 2'000, {{{0, 0}, 29, {{10}, {{{10}, {10}, {10}, {10}}}}}}}; + auto habitat = evo::biology::CellularHabitat::create(std::move(habitat_config)); + CHECK(habitat); + auto created = CellularLives::create( + **primitive, std::move(*habitat), {{3'000, 2'000}, 1, 293'150}); + CHECK(created); + auto& owner = **created; + CHECK(owner.world() == 90 && owner.region() == 1 && owner.frame() == 7); + CHECK(owner.lives().size() == 2 && owner.tick() == 1); + CHECK(owner.current_total() == owner.opening_total()); + + const std::array invalid{CellularLifeIntent{1, {}}, CellularLifeIntent{1, {}}}; + const auto refused = owner.advance_tick(invalid); + CHECK(!refused && owner.tick() == 1 && owner.lives().size() == 2); + + const auto first_life_id = owner.lives()[0].identity.life; + const auto second_life_id = owner.lives()[1].identity.life; + const std::array invalid_motion{ + CellularLifeIntent{first_life_id, {}}, + CellularLifeIntent{second_life_id, {{1'001, 0}, std::nullopt}}}; + const auto partial = owner.advance_tick(invalid_motion); + CHECK(!partial && partial.error() == CellularLivesError::region_step && owner.tick() == 1 && + owner.lives().size() == 2); + + const std::array feed{CellularLifeIntent{first_life_id, {{0, 0}, {{0, 0}}}}, + CellularLifeIntent{second_life_id, {{0, 0}, {{0, 0}}}}}; + const auto fed = owner.advance_tick(feed); + CHECK(fed && owner.tick() == 2 && owner.lives().size() == 2); + CHECK(fed->lives.size() == 2 && + fed->lives[0].candidate.intake_status == evo::biology::CellularIntakeStatus::acquired); + CHECK(owner.habitat().patches()[0].stock == (Inventory{{0}, {}})); + CHECK(owner.current_total() == owner.opening_total()); + + std::size_t steps{}; + while (!owner.lives().empty() && steps < 2'000) { + std::vector idle; + idle.reserve(owner.lives().size()); + for (const auto& life : owner.lives()) + idle.push_back({life.identity.life, {}}); + const auto advanced = owner.advance_tick(idle); + CHECK(advanced && owner.current_total() == owner.opening_total()); + ++steps; + } + CHECK(owner.lives().empty() && owner.corpses().size() == 2 && steps < 2'000); + CHECK(owner.corpses()[0].organism == 101 && owner.corpses()[0].died_tick <= owner.tick()); + CHECK(owner.corpses()[1].organism == 102 && owner.corpses()[1].died_tick <= owner.tick()); + const auto lineage = owner.archive().organism(101); + CHECK(lineage && !lineage->alive && lineage->died.value == owner.corpses()[0].died_tick); + const auto second_lineage = owner.archive().organism(102); + CHECK(second_lineage && !second_lineage->alive && + second_lineage->died.value == owner.corpses()[1].died_tick); + CHECK(owner.heat().energy.value != 0); + CHECK(owner.current_total() == owner.opening_total()); +} +} // namespace + +int main() { + try { + owner_advances_and_closes_death_atomically(); + std::puts("PASS cellular lives: feeding, tick ownership and terminal closure"); + } catch (const std::exception& error) { + std::fprintf(stderr, "%s\n", error.what()); + return 1; + } +}