Add in-memory cellular life owner
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 41s
Foundation / checks (ecs) (push) Successful in 1m50s
Foundation / checks (postgres) (push) Failing after 50s
Foundation / checks (tsan) (push) Failing after 33s
Foundation / checks (network) (push) Failing after 3m6s
Foundation / checks (client) (push) Failing after 4m24s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped

This commit is contained in:
dingo
2026-10-10 22:20:29 -04:00
parent e7fec914e7
commit 562781ce77
7 changed files with 500 additions and 5 deletions
+6 -1
View File
@@ -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)
+7 -4
View File
@@ -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
+4
View File
@@ -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.
+18
View File
@@ -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.
@@ -0,0 +1,94 @@
#pragma once
#include "evo/biology/cellular_region_step.hpp"
#include "evo/server/lifecycle/primitive_lives.hpp"
#include <compare>
#include <cstdint>
#include <expected>
#include <memory>
#include <span>
#include <vector>
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<std::unique_ptr<CellularLives>, CellularLivesError>
create(const PrimitiveLives& opening, std::unique_ptr<biology::CellularHabitat> 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<const CellularOwnedLife> lives() const noexcept;
[[nodiscard]] std::span<const CellularOwnedCorpse> 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<biology::CellularRegionStepCandidate, CellularLivesError>
advance_tick(std::span<const CellularLifeIntent> intents);
private:
struct State;
explicit CellularLives(std::unique_ptr<State> state);
std::unique_ptr<State> state_;
};
} // namespace evo::server
+266
View File
@@ -0,0 +1,266 @@
#include "evo/server/lifecycle/cellular_lives.hpp"
#include <algorithm>
#include <limits>
#include <utility>
namespace evo::server {
namespace {
bool add_inventory(accounting::Inventory& total, const accounting::Inventory& value) noexcept {
constexpr auto maximum = std::numeric_limits<std::uint64_t>::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<biology::MetabolicBudget, CellularLivesError>
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<accounting::Inventory, CellularLivesError>
sum_state(accounting::Inventory nursery, accounting::Inventory heat,
const biology::CellularHabitat& habitat, std::span<const CellularOwnedLife> lives,
std::span<const CellularOwnedCorpse> 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<biology::CellularHabitat> habitat;
std::vector<CellularOwnedLife> lives;
std::vector<CellularOwnedCorpse> 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<biology::CellularHabitat> map,
std::vector<CellularOwnedLife> living, std::vector<CellularOwnedCorpse> 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) : state_{std::move(state)} {}
CellularLives::~CellularLives() = default;
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::create(const PrimitiveLives& opening,
std::unique_ptr<biology::CellularHabitat> 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<CellularOwnedLife> 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<std::size_t>(primitive.body.value - 1);
const auto reserve_index = static_cast<std::size_t>(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<std::uint64_t>(primitive.site.x_um),
static_cast<std::uint64_t>(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<State>(
nursery_config.world, nursery_config.region, nursery_config.frame, config,
std::move(habitat), std::move(lives), std::vector<CellularOwnedCorpse>{},
opening.archive(), nursery, heat, initial_total, *current);
return std::unique_ptr<CellularLives>{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<const CellularOwnedLife> CellularLives::lives() const noexcept { return state_->lives; }
std::span<const CellularOwnedCorpse> 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<biology::CellularRegionStepCandidate, CellularLivesError>
CellularLives::advance_tick(std::span<const CellularLifeIntent> intents) {
if (state_->config.tick == std::numeric_limits<std::uint64_t>::max())
return std::unexpected{CellularLivesError::invalid_tick};
if (intents.size() != state_->lives.size())
return std::unexpected{CellularLivesError::invalid_intents};
std::vector<CellularLifeIntent> 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<biology::CellularLifeStepInput> 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<std::uint64_t>::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>(
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
+105
View File
@@ -0,0 +1,105 @@
#include "evo/server/lifecycle/cellular_lives.hpp"
#include <array>
#include <cstdio>
#include <source_location>
#include <stdexcept>
#include <string>
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<bool>(__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<CellularLifeIntent> 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;
}
}