diff --git a/deploy/kubernetes/region/dev-session-route/listener.yaml b/deploy/kubernetes/region/dev-session-route/listener.yaml index c3b92ae..1d8c018 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-20261009T171039-559d:1791579639"} + - {name: REGION_SESSION_WINDOW, value: "dev-20261009T184926-c2b9:1791585566"} - {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 620c952..598bd89 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -24,8 +24,13 @@ the maintainer chose directional rounding): read ×20 and never rewritten. Development version 1 converts at its own 50 ms quantum, mutation keeps a lineage's schema, and an archive of schema 1 records keeps its bytes. No behaviour or golden changed. -- **Segment 3 (next):** development outputs, feeding and decay limits per second, - converted at each process's tick. +- **Segment 3 (done):** environmental community rules 3 states irradiance, growth, + intake and decay per second. At 50 ms it steps identically to its rules 2 twin. The + dev world's rules 2 opening is unchanged. Development version 1 outputs stay tied to + their declared 50 ms quantum. The tick-abstract M2 fixtures are not migrated. ADR-0089's + rate migration is complete. +- **Next in 11.1:** development version 2, a first bud fundable within a session + (ADR-0098 decision 7). Open from M10 (BACKLOG): - the maintainer's native-client observation, moved to the later 2k drill; diff --git a/docs/adr/0099-time-based-biological-rates.md b/docs/adr/0099-time-based-biological-rates.md index 5726259..f7183d7 100644 --- a/docs/adr/0099-time-based-biological-rates.md +++ b/docs/adr/0099-time-based-biological-rates.md @@ -98,6 +98,31 @@ contract and a versioned migration that preserves 50 ms behaviour. - **Tests that used 2 as an unknown future schema** now use the next unknown one. The archive decoder refuses a header that misstates its contents. +## Segment 3 as implemented (2026-10-09) +- **Environmental community rules 3** is rules 2 with every rate per second: + irradiance and growth as rationals per second, and intake and decay caps per + second. + - At creation and restore, the community derives its per-tick form once. The + rationals convert exactly, because the tick folds into numerator and denominator. + The caps round down. + - Steps run on that form unchanged, the snapshot keeps rules 2's layout, and the + codec reads rules 1 to 3. + - At 50 ms, a ×20 per-second twin of a rules 2 configuration steps identically + through feeding, death and decay, and across a snapshot. At 25 ms the caps halve. + - Rules 1 and 2, including the dev world's fixed `development-v1` opening, are + unchanged. +- **Development version 1 outputs** (maintenance, movement, intake limit) stay per + tick of its 50 ms quantum, which is how that version is defined. + - A live process at another tick reads them through `per_second_from_per_tick` and + `per_tick`. + - Development version 2 (the birth-cost re-derivation, ADR-0098) is defined per + second natively. +- **The M2 ecosystem fixtures** (consumer and producer configurations, the feeding + decomposition limit) are tick-abstract test oracles with no time base, and are not + migrated. New gameplay processes (11.3) use per-second rates from the start. +- **Result:** every rate that a live world can run on is now either per second + (genome schema 2, rules 3) or tied to a declared quantum it converts from. + ## Consequences - Segment 1: `accounting/rates.hpp` (`per_tick`, `exact_per_tick`, `per_second_from_per_tick`) and the `rate-contracts` test. diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index a735c4c..5064767 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -5399,3 +5399,27 @@ Executed: - The 18 Postgres suites passed, including region upgrade and clone comparison, so checkpoints are unchanged. - Windows `debug`: 61/61. + +## 2026-10-09 — M11.1 time-based rates, segment 3: environmental rules 3 (ADR-0099) + +Environmental community rules 3 has rules 2's layout with irradiance, growth, intake +and decay per second. It derives a per-tick form at creation and restore: exact +rationals, caps rounded down. Its format is 3 (`schemas/environmental-community.md`). +Development version 1 outputs stay tied to their 50 ms quantum, and the +tick-abstract M2 fixtures are not migrated. Both are recorded in ADR-0099. + +`rules3_per_second` tests: +- a ×20 twin of a rules 2 configuration over 60 ticks, through feeding, a consumer + death and decay, with reports and every inventory equal each tick; +- snapshot and restore as format 3, then identical steps; +- at 25 ms, a 2000-per-second intake cap admits 50 and refuses 51; +- an overflowing rate and an over-long tick are refused. + +`environmental-qualification` used rules 3 as "unknown". It now uses 4, with the same +intent. + +Executed: +- WSL `linux-debug` and `linux-asan`: 61/61 after that change. +- clang-tidy 19 on the changed sources and tests: clean. +- The 18 Postgres suites: passed. +- Windows `debug`: 61/61. diff --git a/include/evo/processes/environmental_community.hpp b/include/evo/processes/environmental_community.hpp index 0aebbe4..130d6ff 100644 --- a/include/evo/processes/environmental_community.hpp +++ b/include/evo/processes/environmental_community.hpp @@ -1,7 +1,11 @@ #pragma once #include "evo/world/transfers.hpp" +#include namespace evo::processes { // Explicit fixture parameters; units and array order in environmental-community.md. +// Rules 1 and 2 state rates per tick of `tick_microseconds`. Rules 3 (ADR-0099) is rules +// 2 with every rate per second: irradiance and growth as rationals per second (converted +// exactly), and intake and decay caps per second (rounded down at the tick). struct EnvironmentalConfig { std::uint64_t rules{1}, world{}, frame{}, producer{}, consumer{}, source{}, tick_microseconds{}, area_um2{}, irradiance_numerator{}, irradiance_denominator{1}, efficiency{}, @@ -9,7 +13,8 @@ struct EnvironmentalConfig { std::array recipe{}, intake{}; std::uint64_t assimilation{}, producer_min_mK{}, producer_max_mK{}, consumer_min_mK{}, consumer_max_mK{}; - std::array decay{}; // Rules 2: shared source-channel caps per tick. + std::array decay{}; // Rules 2+: shared source-channel caps per tick + // (rules 3: per second). auto operator<=>(const EnvironmentalConfig&) const = default; }; struct EnvironmentalInput { @@ -89,11 +94,14 @@ class EnvironmentalCommunity { EnvironmentalCommunity() = default; [[nodiscard]] State state() const noexcept; [[nodiscard]] bool valid(const State& s) const noexcept; - [[nodiscard]] static bool configuration(const EnvironmentalConfig& c, - const world::EnvironmentalTransfers& r) noexcept; + // Validates a configuration and returns its per-tick form (itself for rules 1 and 2; + // rules 3's rates converted at its tick), or nothing when invalid. + [[nodiscard]] static std::optional + configuration(const EnvironmentalConfig& c, const world::EnvironmentalTransfers& r) noexcept; [[nodiscard]] std::expected step(State& candidate, std::uint64_t tick, const EnvironmentalInput& input) const noexcept; - EnvironmentalConfig config_{}; + EnvironmentalConfig config_{}; // As configured and persisted. + EnvironmentalConfig step_{}; // Its per-tick form, which every step uses. std::unique_ptr resources_; EnvironmentalProgress progress_{}; State anchor_{}; diff --git a/schemas/environmental-community.md b/schemas/environmental-community.md index 98614be..b90ad9b 100644 --- a/schemas/environmental-community.md +++ b/schemas/environmental-community.md @@ -1,5 +1,23 @@ # Environmental community envelope v1 (M6.5c) +## Version 3: rates per second (M11.1, ADR-0099) + +Format 3 requires rules 3 and has format 2's layout byte for byte. Only the units of +five rates change: +- **irradiance:** `irradiance_numerator / irradiance_denominator`, in pJ per um^2 per + second; +- **growth:** `growth_numerator / growth_denominator`, in units per second; +- **intake[5] and decay[10]:** whole fg or pJ per second. + +At creation and restore, the community derives a per-tick rules 2 form at +`tick_microseconds` (1 us to 1 s). +- The rationals become `numerator * tick / (denominator * 10^6)`, which is exact. + Their remainders are stored at that scale. +- The caps round down, never exceeding the per-second rate. +- A rate that overflows at the tick is a configuration error. + +Formats 1 and 2 are unchanged and replay their own rules. + ## Version 2 extension (M6.6, ADR-0056) Format 2 requires rules 2; format 1 requires rules 1. The v1 layout below is diff --git a/src/processes/environmental_codec.cpp b/src/processes/environmental_codec.cpp index a20b04c..1807a76 100644 --- a/src/processes/environmental_codec.cpp +++ b/src/processes/environmental_codec.cpp @@ -117,7 +117,7 @@ std::expected EnvironmentalCommunity::snapsho auto resource = resources_->snapshot(); if (!resource) return std::unexpected{CommunityError::resources}; - const bool extended = config_.rules == 2; + const bool extended = config_.rules >= 2; // Rules 3 has rules 2's layout. const auto length = (extended ? 712 : 616) + count_ * (extended ? 304 : 200) + resource->size(); if (length > max_snapshot_bytes) return std::unexpected{CommunityError::budget}; @@ -150,8 +150,8 @@ EnvironmentalCommunity::restore(std::span bytes, world::Worl if (r.get() != magic) return std::unexpected{CommunityError::format}; const auto version = r.get(); - const bool extended = version == 2; - if (version != 1 && version != 2) + const bool extended = version >= 2; + if (version < 1 || version > 3) return std::unexpected{CommunityError::version}; if (r.get() != bytes.size()) return std::unexpected{CommunityError::format}; @@ -189,8 +189,11 @@ EnvironmentalCommunity::restore(std::span bytes, world::Worl o->budget_ = budget; o->count_ = static_cast(count); o->next_ = o->count_ % history_limit; - if (!configuration(o->config_, *o->resources_) || - o->resources_->adoption_command_ != o->progress_.tick || + const auto step = configuration(o->config_, *o->resources_); + if (!step) + return std::unexpected{CommunityError::format}; + o->step_ = *step; + if (o->resources_->adoption_command_ != o->progress_.tick || o->resources_->fields().last_command() != o->progress_.tick || std::ranges::any_of(o->resources_->history_, [](const auto& h) { return h.receipt.command != 0; }) || diff --git a/src/processes/environmental_community.cpp b/src/processes/environmental_community.cpp index d70ebfb..8d67788 100644 --- a/src/processes/environmental_community.cpp +++ b/src/processes/environmental_community.cpp @@ -1,4 +1,5 @@ #include "evo/processes/environmental_community.hpp" +#include "evo/accounting/rates.hpp" #include #include namespace evo::processes { @@ -16,12 +17,46 @@ std::uint64_t portion(std::uint64_t x, std::uint64_t a) { bool EnvironmentalCommunity::rebind_world(std::uint64_t world) noexcept { if (world == 0) return false; - config_.world = world; + config_.world = step_.world = world; resources_->rebind({world, config_.frame}); return true; } -bool EnvironmentalCommunity::configuration(const EnvironmentalConfig& c, - const world::EnvironmentalTransfers& r) noexcept { +std::optional +EnvironmentalCommunity::configuration(const EnvironmentalConfig& given, + const world::EnvironmentalTransfers& r) noexcept { + if (given.rules < 1 || given.rules > 3) + return std::nullopt; + // Rules 3 runs as rules 2 with its per-second rates converted at the tick (ADR-0099): + // the rationals exactly (the tick folds into numerator and denominator), the caps + // rounded down. + auto c = given; + if (given.rules == 3) { + const auto tick = given.tick_microseconds; + constexpr auto second = accounting::microseconds_per_second; + if (tick == 0 || tick > accounting::max_tick_microseconds || + given.irradiance_numerator > maximum / tick || + given.irradiance_denominator > maximum / second || + given.growth_numerator > maximum / tick || given.growth_denominator > maximum / second) + return std::nullopt; + c.rules = 2; + c.irradiance_numerator = given.irradiance_numerator * tick; + c.irradiance_denominator = given.irradiance_denominator * second; + c.growth_numerator = given.growth_numerator * tick; + c.growth_denominator = given.growth_denominator * second; + for (std::size_t j = 0; j < c.intake.size(); ++j) { + const auto cap = + accounting::per_tick(given.intake[j], tick, accounting::Rounding::down); + if (!cap) + return std::nullopt; + c.intake[j] = *cap; + } + for (std::size_t k = 0; k < c.decay.size(); ++k) { + const auto cap = accounting::per_tick(given.decay[k], tick, accounting::Rounding::down); + if (!cap) + return std::nullopt; + c.decay[k] = *cap; + } + } if ((c.rules != 1 && c.rules != 2) || (c.rules == 1 && std::ranges::any_of(c.decay, [](auto v) { return v != 0; })) || c.world == 0 || c.frame == 0 || @@ -30,21 +65,21 @@ bool EnvironmentalCommunity::configuration(const EnvironmentalConfig& c, c.growth_denominator == 0 || c.efficiency > 1000 || c.assimilation > 1000 || c.growth_cost == 0 || c.producer_min_mK == 0 || c.consumer_min_mK == 0 || c.producer_min_mK > c.producer_max_mK || c.consumer_min_mK > c.consumer_max_mK) - return false; + return std::nullopt; if (r.fields().sites().size() != 1 || r.terrain().size() != 1 || r.organisms().size() != 2 || r.organisms()[0].id.value != c.producer || r.organisms()[1].id.value != c.consumer) - return false; + return std::nullopt; const auto measure = world::measure_habitat(r.fields().sites()[0].box); if (!measure || c.area_um2 > measure->area.value || c.irradiance_numerator > maximum / c.area_um2) - return false; + return std::nullopt; for (std::size_t k = 0; k < 10; ++k) if (!r.fields().read(0, static_cast(k))) - return false; + return std::nullopt; for (std::size_t k = 0; k < 4; ++k) if (c.recipe[k] == 0) - return false; - return true; + return std::nullopt; + return c; } EnvironmentalCommunity::State EnvironmentalCommunity::state() const noexcept { State s; @@ -58,8 +93,8 @@ EnvironmentalCommunity::State EnvironmentalCommunity::state() const noexcept { bool EnvironmentalCommunity::valid(const State& s) const noexcept { const auto& p = s.progress; if ((p.last_funded == 0 && (p.source_remainder != 0 || p.efficiency_remainder != 0)) || - p.source_remainder >= config_.irradiance_denominator || - p.growth_remainder >= config_.growth_denominator || p.efficiency_remainder >= 1000 || + p.source_remainder >= step_.irradiance_denominator || + p.growth_remainder >= step_.growth_denominator || p.efficiency_remainder >= 1000 || p.last_funded > p.tick || p.producer_terminal > 1 || p.consumer_terminal > 1 || (config_.rules == 1 && p.consumer_terminal != 0) || (p.tick == 0 && p != EnvironmentalProgress{})) @@ -88,13 +123,15 @@ std::expected, CommunityError> EnvironmentalCommunity::create(EnvironmentalConfig c, std::unique_ptr r, std::size_t budget) { - if (!r || !configuration(c, *r) || r->fields().last_command() != 0 || r->adoption_command_ != 0) + const auto step = r ? configuration(c, *r) : std::nullopt; + if (!step || r->fields().last_command() != 0 || r->adoption_command_ != 0) return std::unexpected{CommunityError::config}; if (budget < sizeof(EnvironmentalCommunity) + 2 * scratch_bytes || r->accounted_bytes() > budget - sizeof(EnvironmentalCommunity) - 2 * scratch_bytes) return std::unexpected{CommunityError::budget}; auto o = std::unique_ptr(new EnvironmentalCommunity); o->config_ = c; + o->step_ = *step; o->resources_ = std::move(r); o->budget_ = budget; o->anchor_ = o->state(); @@ -106,7 +143,7 @@ EnvironmentalCommunity::step(State& s, std::uint64_t tick, if (input.temperature_mK == 0 || input.source_enabled > 1) return std::unexpected{CommunityError::input}; auto& p = s.progress; - const auto& c = config_; + const auto& c = step_; EnvironmentalReport report{}; report.tick = tick; if (input.terminal[0] > 1 || input.terminal[1] > 1 || diff --git a/tests/environmental_community_tests.cpp b/tests/environmental_community_tests.cpp index aec13a7..e1dc481 100644 --- a/tests/environmental_community_tests.cpp +++ b/tests/environmental_community_tests.cpp @@ -523,6 +523,83 @@ void interval_boundaries() { } } } // namespace +// Rules 3 (ADR-0099): rules 2 with every rate per second. At 50 ms a per-second twin of a +// rules 2 configuration (rates times 20) steps identically, through feeding, a death and +// its decay, and across a snapshot; at another tick the caps scale and round down. +void rules3_per_second() { + auto two = config(); + two.rules = 2; + two.growth_numerator = 3; + two.growth_denominator = 2; + two.decay.fill(2); + auto three = two; + three.rules = 3; + three.irradiance_numerator *= 20; + three.growth_numerator *= 20; + for (auto& v : three.intake) + v *= 20; + for (auto& v : three.decay) + v *= 20; + const std::array stock{5, 5, 5, 5, 5, 5, 5, 5, 5, 5}; + auto made_a = EnvironmentalCommunity::create( + two, resources({100, 100, 100, 100, 0, 0, 100, 0, 10, 0}, stock, stock), 8000000); + auto made_b = EnvironmentalCommunity::create( + three, resources({100, 100, 100, 100, 0, 0, 100, 0, 10, 0}, stock, stock), 8000000); + CHECK(made_a && made_b); + auto a = std::move(*made_a); + auto b = std::move(*made_b); + const auto same = [&] { + for (std::size_t k = 0; k < 10; ++k) + if (*a->resources().fields().read(0, static_cast(k)) != + *b->resources().fields().read(0, static_cast(k))) + return false; + return a->resources().organisms()[0].balances == b->resources().organisms()[0].balances && + a->resources().organisms()[1].balances == b->resources().organisms()[1].balances; + }; + const auto input = [](std::uint64_t tick) { + EnvironmentalInput in{290000, tick % 7 == 0 ? 0U : 1U, {}, {}}; + if (tick == 6) + in.bite = {1, 1, 1, 1, 1}; + if (tick == 20) + in.terminal = {0, 1}; + return in; + }; + for (std::uint64_t tick = 1; tick <= 40; ++tick) { + const auto ra = a->advance(tick, input(tick)); + const auto rb = b->advance(tick, input(tick)); + CHECK(ra.has_value() == rb.has_value()); + if (ra) + CHECK(*ra == *rb); + CHECK(same()); + } + // Rules 3 persists as rules 3 and replays from its snapshot. + const auto saved = b->snapshot(); + CHECK(saved && (*saved)[8] == 3); + auto restored = EnvironmentalCommunity::restore(*saved, identity, 8000000); + CHECK(restored && (*restored)->snapshot() == saved); + b = std::move(*restored); + for (std::uint64_t tick = 41; tick <= 60; ++tick) { + const auto ra = a->advance(tick, input(tick)); + const auto rb = b->advance(tick, input(tick)); + CHECK(ra && rb && *ra == *rb && same()); + } + // At 25 ms a cap of 2000 per second is 50 per tick: 51 is over it, 50 is within it. + auto fast = three; + fast.tick_microseconds = 25000; + auto quick = make(fast); + const auto over = quick->advance(1, {290000, 0, {51, 0, 0, 0, 0}, {}}); + CHECK(!over && over.error() == CommunityError::input); + const auto within = quick->advance(1, {290000, 0, {50, 0, 0, 0, 0}, {}}); + CHECK(!within && within.error() == CommunityError::insufficient); // Past the cap check. + // A rate that cannot be converted at the tick is a configuration error. + auto huge = three; + huge.irradiance_numerator = std::numeric_limits::max(); + CHECK(!EnvironmentalCommunity::create(huge, resources(), 8000000)); + auto slow = three; + slow.tick_microseconds = 1'000'001; + CHECK(!EnvironmentalCommunity::create(slow, resources(), 8000000)); +} + int main() { try { vectors(); @@ -533,6 +610,7 @@ int main() { decay_continuation(); scheduled_intervals(); interval_boundaries(); + rules3_per_second(); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); diff --git a/tests/environmental_qualification.cpp b/tests/environmental_qualification.cpp index 6f9c769..45b5ab0 100644 --- a/tests/environmental_qualification.cpp +++ b/tests/environmental_qualification.cpp @@ -117,7 +117,7 @@ void refusals() { auto c = config(); switch (which) { case 0: - c.rules = 3; // Rules 2 are the M6.6 terminal/decay extension. + c.rules = 4; // Unknown: 2 is the M6.6 terminal/decay extension, 3 per second. break; case 1: c.world = 8;