Compose single-life cellular tick proposals
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m51s
Foundation / checks (client) (push) Failing after 4m32s
Foundation / checks (network) (push) Failing after 3m3s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 52s
Foundation / checks (tsan) (push) Canceled after 24s
Foundation / checks (checks) (push) Canceled after 5m28s

This commit is contained in:
dingo
2026-10-10 21:24:39 -04:00
parent 6816eda6a5
commit 1ccc0ce476
8 changed files with 333 additions and 1 deletions
+6 -1
View File
@@ -70,7 +70,7 @@ add_library(evo_biology STATIC
src/biology/genome.cpp src/biology/development.cpp src/biology/metabolism.cpp
src/biology/mutation.cpp src/biology/lineage.cpp src/biology/founder.cpp
src/biology/cellular_motion.cpp src/biology/cellular_uptake.cpp
src/biology/cellular_habitat.cpp)
src/biology/cellular_habitat.cpp src/biology/cellular_step.cpp)
add_library(evo::biology ALIAS evo_biology)
target_include_directories(evo_biology PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_link_libraries(evo_biology PUBLIC evo::accounting)
@@ -440,6 +440,11 @@ if(BUILD_TESTING)
evo_owned_target(evo-cellular-habitat-tests)
add_test(NAME cellular-habitat-contracts COMMAND evo-cellular-habitat-tests)
set_tests_properties(cellular-habitat-contracts PROPERTIES TIMEOUT 60)
add_executable(evo-cellular-step-tests tests/cellular_step_tests.cpp)
target_link_libraries(evo-cellular-step-tests PRIVATE evo::biology)
evo_owned_target(evo-cellular-step-tests)
add_test(NAME cellular-step-contracts COMMAND evo-cellular-step-tests)
set_tests_properties(cellular-step-contracts PROPERTIES TIMEOUT 60)
add_executable(evo-primitive-lives-tests tests/primitive_lives_tests.cpp)
target_link_libraries(evo-primitive-lives-tests PRIVATE evo::lifecycle)
evo_owned_target(evo-primitive-lives-tests)
@@ -0,0 +1,59 @@
# ADR-0104: Cellular single-life tick order trial
## Status
Accepted direction for the M11.3 exploratory slice (2026-10-10). This orders a
single-life proposal only; the region transaction must resolve shared patch
claims and durable actions before the rule is used for multiple organisms.
## Context
ADR-0098 selects phenotype-derived maintenance, movement and intake with
movement and engulf intentions. ADR-0099 defines rate conversion at the fixed
50 ms tick boundary. ADR-0101 and ADR-0102 supply finite resources, bounded
movement and footprint contact. These independent proposals need an explicit
order so energy acquired during a tick cannot retroactively fund actions earlier
in that tick.
## Decision
For the first one-life cellular trial step, the authoritative resolver produces
one detached candidate in this order:
1. Charge one tick of maintenance from the starting reserve to heat, rounded up.
If it cannot be paid, return `insufficient_maintenance`; the later life/death
owner must resolve starvation in this same tick before publication.
2. Resolve bounded movement from the post-maintenance reserve. If the move is
unaffordable, the organism remains in place and the tick continues; it cannot
spend resources it will acquire later in the tick. Paid movement energy goes
to heat.
3. If an intake target was supplied, validate its patch exists and the resulting
footprint contacts it. A missing or out-of-contact target is reported without
intake, while the already-proposed maintenance and movement remain in the
candidate. A valid target receives the one-tick channel-limited transfer.
4. Publish position, reserve, heat, patch stock and tick together. Every resource
channel is conserved. This resolver does not grow the body, replenish patches,
resolve a second life's claim, or commit state itself.
An intake in this trial addresses one provisioned patch per life per tick. The
perception projection is the only intended way for a client to learn target
addresses; the server still validates range at view creation and contact at
resolution. Later multi-life resolution must arbitrate all claims against one
shared candidate habitat before invoking or replacing this single-life helper.
## Alternatives considered
- **Intake before movement:** rejected because newly absorbed energy could fund
movement in the same tick, making costs depend on action ordering.
- **Refuse the whole tick when movement is underfunded:** rejected because a
cell may still maintain itself and feed while stationary.
- **Silently skip unaffordable maintenance:** rejected because it would allow a
nonviable cell to remain active without paying upkeep.
## Consequences
The pure biology resolver composes rate conversion, movement affordability,
heat transfer and one contact-gated patch intake into a detached value. It is
not yet connected to life ownership, shared-stock contention, the cellular
checkpoint, network intentions or durable outcomes. Those integrations are
required before the exploratory hands-on probe.
+1
View File
@@ -4,6 +4,7 @@
- [ADR-0101: Cellular microhabitat resource sites](0101-cellular-microhabitat-resources.md) - accepted M11.3 direction for finite, conserved sub-voxel food patches; 1 mm pitch is a versioned exploratory tunable, with no meter-scale coupling yet.
- [ADR-0102: Bounded cellular space and locomotion trial](0102-cellular-spatial-trial.md) - accepted M11.3 trial direction for finite 2D region bounds, phenotype-limited movement and organism contact; tunable arena dimensions are not world geometry.
- [ADR-0103: Cellular resource perception trial](0103-cellular-perception-trial.md) - accepted M11.3 exploratory direction for a 5 mm footprint-based sensor range and exact nearby patch stock; provenance and out-of-range stock remain hidden.
- [ADR-0104: Cellular single-life tick order trial](0104-cellular-single-life-tick-order.md) - accepted M11.3 order for maintenance, funded movement and one contact-gated intake proposal; shared-stock contention and durable publication remain open.
- [ADR-0058: Region durability contract](0058-region-durability-contract.md) - accepted M7.1 full checkpoint batches and explicit state closure; storage implementation follows.
+4
View File
@@ -123,6 +123,10 @@ scoped change before starting the next segment.
- 11.3b-2: funded motion now returns one detached position/reserve/heat
candidate and refuses underfunded or overflowing movement without partial
debit. Live intent admission, tick publication and recovery remain open.
- 11.3c-3: ADR-0104 and a single-life tick resolver compose maintenance,
affordable movement and one targeted contact intake into a detached candidate.
Shared-stock contention, starvation/death closure, owner commit and checkpoint
recovery remain open; this helper is not yet a multi-life tick.
## Exit boundary
+17
View File
@@ -5888,6 +5888,23 @@ dry-run; clang-tidy 19.1.5 using the MSVC `/std:c++latest` argument; and
the full CI suite remain pending CI. This projection is not yet wired into live
replication or a persistent cellular checkpoint.
## 2026-10-10 — M11.3c-3 single-life cellular tick (CI pending)
Added ADR-0104 and a pure one-life tick candidate. It debits per-tick
maintenance first, attempts movement only from the remaining starting reserve,
and applies one explicitly targeted intake only after movement and contact
validation. An unaffordable move leaves the cell still while maintenance and
valid intake remain in the candidate; unaffordable maintenance refuses the
candidate for same-tick starvation resolution by the later life owner. The
returned balances conserve energy and each matter channel. No owner, shared-stock
arbitration, death closure or durable publication has been integrated.
Executed locally: warning-as-error MSVC 19.44 Debug and Release `NDEBUG`
compile/run; focused CTest for motion, uptake, habitat and the composed tick
(4/4 passed); clang-format 19.1.5 dry-run; clang-tidy 19.1.5 using MSVC
`/std:c++latest`; and `git diff --check`. Linux sanitizers, shared-life
contention and server/checkpoint integration remain pending CI and later gates.
## 2026-10-10 — M11.3c-2 contact-gated patch uptake (CI pending)
The habitat uptake proposal now validates the cell footprint against the finite
+43
View File
@@ -0,0 +1,43 @@
#pragma once
#include "evo/biology/cellular_habitat.hpp"
#include <cstdint>
#include <optional>
namespace evo::biology {
struct CellularStepIntent {
CellularIntent movement{};
std::optional<CellularPatchAddress> intake_target;
auto operator<=>(const CellularStepIntent&) const = default;
};
enum class CellularStepError : std::uint8_t {
invalid_tick,
unsupported_rate_period,
insufficient_maintenance,
overflow,
motion
};
enum class CellularIntakeStatus : std::uint8_t { not_requested, acquired, missing, out_of_contact };
// Complete detached candidate for one 50 ms life tick. Maintenance is charged
// first; unaffordable motion leaves the cell stationary, then one targeted patch
// may be absorbed at the resulting position. Publication owns the final swap.
struct CellularStepCandidate {
std::uint64_t begin_tick{}, end_tick{};
CellularPosition position;
accounting::Inventory reserve_after;
accounting::Inventory heat_after;
accounting::Picojoules maintenance_cost{}, movement_cost{};
CellularIntakeStatus intake_status{CellularIntakeStatus::not_requested};
std::optional<CellularPatchUptakeProposal> intake;
auto operator<=>(const CellularStepCandidate&) const = default;
};
[[nodiscard]] std::expected<CellularStepCandidate, CellularStepError>
propose_cellular_step(std::uint64_t begin_tick, CellularArea area, CellularPosition position,
std::uint32_t extent_um, CellularStepIntent intent,
accounting::Inventory reserve, accounting::Inventory heat,
const MetabolicBudget& budget, const CellularHabitat& habitat) noexcept;
} // namespace evo::biology
+81
View File
@@ -0,0 +1,81 @@
#include "evo/biology/cellular_step.hpp"
#include "evo/accounting/rates.hpp"
#include "evo/biology/cellular_motion.hpp"
#include <limits>
namespace evo::biology {
namespace {
constexpr std::uint64_t rate_period_microseconds = 1'000'000;
bool credit_heat(accounting::Inventory& heat, std::uint64_t amount) noexcept {
if (heat.energy.value > std::numeric_limits<std::uint64_t>::max() - amount)
return false;
heat.energy.value += amount;
return true;
}
} // namespace
std::expected<CellularStepCandidate, CellularStepError>
propose_cellular_step(std::uint64_t begin_tick, CellularArea area, CellularPosition position,
std::uint32_t extent_um, CellularStepIntent intent,
accounting::Inventory reserve, accounting::Inventory heat,
const MetabolicBudget& budget, const CellularHabitat& habitat) noexcept {
if (begin_tick == std::numeric_limits<std::uint64_t>::max())
return std::unexpected{CellularStepError::invalid_tick};
if (budget.rate_microseconds != rate_period_microseconds)
return std::unexpected{CellularStepError::unsupported_rate_period};
if (area.width_um != habitat.config().width_um || area.height_um != habitat.config().height_um)
return std::unexpected{CellularStepError::motion};
const auto maintenance = accounting::per_tick(
budget.maintenance.value, cellular_motion_tick_microseconds, accounting::Rounding::up);
if (!maintenance)
return std::unexpected{CellularStepError::overflow};
if (reserve.energy.value < *maintenance)
return std::unexpected{CellularStepError::insufficient_maintenance};
if (!credit_heat(heat, *maintenance))
return std::unexpected{CellularStepError::overflow};
reserve.energy.value -= *maintenance;
const auto movement = propose_funded_cellular_motion(area, position, extent_um, intent.movement,
budget, reserve, heat);
if (!movement && movement.error() != CellularMotionError::insufficient_reserve)
return std::unexpected{CellularStepError::motion};
if (movement) {
position = movement->position;
reserve = movement->reserve_after;
heat = movement->heat_after;
}
CellularStepCandidate candidate{
begin_tick, begin_tick + 1, position, reserve,
heat, {*maintenance}, {}, CellularIntakeStatus::not_requested,
{}};
if (movement)
candidate.movement_cost = movement->movement_cost;
if (!intent.intake_target)
return candidate;
const auto intake =
habitat.propose_uptake(*intent.intake_target, position, extent_um, reserve, budget);
if (!intake) {
if (intake.error() == CellularHabitatError::missing_patch) {
candidate.intake_status = CellularIntakeStatus::missing;
return candidate;
}
if (intake.error() == CellularHabitatError::not_in_contact) {
candidate.intake_status = CellularIntakeStatus::out_of_contact;
return candidate;
}
return std::unexpected{intake.error() == CellularHabitatError::uptake
? CellularStepError::overflow
: CellularStepError::motion};
}
candidate.reserve_after = intake->transfer.reserve_after;
candidate.intake_status = CellularIntakeStatus::acquired;
candidate.intake = *intake;
return candidate;
}
} // namespace evo::biology
+122
View File
@@ -0,0 +1,122 @@
#include "evo/biology/cellular_step.hpp"
#include <cstdio>
#include <limits>
#include <source_location>
#include <stdexcept>
#include <string>
namespace {
using namespace evo::biology;
using evo::accounting::Inventory;
void check(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("cellular step line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
MetabolicBudget budget() {
MetabolicBudget result{};
result.phenotype.movement_speed = 200;
result.maintenance = {100};
result.movement = {1'000};
result.intake_limit = {{1'000}, {{{100}, {50}, {25}, {10}}}};
result.rate_microseconds = 1'000'000;
return result;
}
std::unique_ptr<CellularHabitat> habitat() {
CellularHabitatConfig opening{
7, 9, 11, 3'000, 2'000, {{{0, 0}, 51, {{1'000}, {{{20}, {10}, {5}, {2}}}}}}};
auto made = CellularHabitat::create(std::move(opening));
CHECK(made);
return std::move(*made);
}
void maintenance_motion_and_intake_conserve_one_tick() {
const Inventory reserve{{200}, {}};
const Inventory heat{};
const auto map = habitat();
const auto step = propose_cellular_step(12, {3'000, 2'000}, {0, 0}, 20,
{{1'000, 0}, CellularPatchAddress{0, 0}}, reserve, heat,
budget(), *map);
if (!step)
throw std::runtime_error("cellular step failed");
CHECK(step->begin_tick == 12 && step->end_tick == 13);
CHECK(step->position == CellularPosition{10, 0});
CHECK(step->maintenance_cost.value == 5 && step->movement_cost.value == 50);
CHECK(step->heat_after.energy.value == 55);
CHECK(step->reserve_after == Inventory{{195}, {{{5}, {2}, {1}, {0}}}});
if (step->intake_status != CellularIntakeStatus::acquired || !step->intake)
throw std::runtime_error("cellular step intake missing");
const auto& intake = *step->intake;
CHECK(intake.transfer.patch_after == Inventory{{950}, {{{15}, {8}, {4}, {2}}}});
CHECK(reserve.energy.value == 200 && heat.energy.value == 0);
CHECK(map->patches()[0].stock == Inventory{{1'000}, {{{20}, {10}, {5}, {2}}}});
const auto& acquired = intake.transfer.acquired;
CHECK(step->reserve_after.energy.value + step->heat_after.energy.value +
intake.transfer.patch_after.energy.value ==
reserve.energy.value + heat.energy.value + map->patches()[0].stock.energy.value);
for (std::size_t channel = 0; channel < acquired.matter.size(); ++channel)
CHECK(step->reserve_after.matter[channel].value +
intake.transfer.patch_after.matter[channel].value ==
reserve.matter[channel].value + map->patches()[0].stock.matter[channel].value);
}
void maintenance_precedes_motion_and_intake() {
const auto map = habitat();
Inventory low_reserve{{54}, {}};
const auto step = propose_cellular_step(1, {3'000, 2'000}, {0, 0}, 20,
{{1'000, 0}, CellularPatchAddress{0, 0}}, low_reserve,
{}, budget(), *map);
CHECK(step);
CHECK(step->position == CellularPosition{0, 0});
CHECK(step->movement_cost.value == 0);
CHECK(step->maintenance_cost.value == 5 && step->heat_after.energy.value == 5);
CHECK(step->intake_status == CellularIntakeStatus::acquired);
CHECK(step->reserve_after.energy.value == 99); // Intake cannot fund this tick's move.
low_reserve.energy.value = 4;
const auto starved =
propose_cellular_step(1, {3'000, 2'000}, {0, 0}, 20, {{}, CellularPatchAddress{0, 0}},
low_reserve, {}, budget(), *map);
CHECK(!starved && starved.error() == CellularStepError::insufficient_maintenance);
}
void refusals_and_noncontact_are_explicit() {
const auto map = habitat();
const auto missed =
propose_cellular_step(4, {3'000, 2'000}, {1'500, 0}, 20, {{}, CellularPatchAddress{0, 0}},
{{100}, {}}, {}, budget(), *map);
CHECK(missed && missed->intake_status == CellularIntakeStatus::out_of_contact);
CHECK(missed->position == CellularPosition{1'500, 0});
CHECK(missed->reserve_after.energy.value == 95);
CHECK(!missed->intake);
const auto absent =
propose_cellular_step(4, {3'000, 2'000}, {0, 0}, 20, {{}, CellularPatchAddress{1'000, 0}},
{{100}, {}}, {}, budget(), *map);
CHECK(absent && absent->intake_status == CellularIntakeStatus::missing);
CHECK(!propose_cellular_step(std::numeric_limits<std::uint64_t>::max(), {3'000, 2'000}, {0, 0},
20, {}, {{100}, {}}, {}, budget(), *map));
CHECK(
!propose_cellular_step(0, {2'000, 2'000}, {0, 0}, 20, {}, {{100}, {}}, {}, budget(), *map));
auto full_heat = Inventory{{std::numeric_limits<std::uint64_t>::max()}, {}};
CHECK(!propose_cellular_step(0, {3'000, 2'000}, {0, 0}, 20, {}, {{100}, {}}, full_heat,
budget(), *map));
}
} // namespace
int main() {
try {
maintenance_motion_and_intake_conserve_one_tick();
maintenance_precedes_motion_and_intake();
refusals_and_noncontact_are_explicit();
std::puts("PASS cellular step: tick order, funded motion and bounded feeding");
} catch (const std::exception& error) {
std::fprintf(stderr, "%s\n", error.what());
return 1;
}
}