Implement M6.6 retained corpses and versioned bounded decay

This commit is contained in:
dingo
2026-09-27 18:37:36 -04:00
parent 6fd553c84b
commit 6dd0e49e45
12 changed files with 392 additions and 27 deletions
+8
View File
@@ -461,3 +461,11 @@ M6.5d native qualification complete: [report](engineering/ENVIRONMENTAL_QUALIFIC
records boundary/malformed-state tests, 16-seed paired restore runs, more than a
million logical ticks and cost evidence. M6.5 is implemented and natively qualified;
Linux CI is separately pending verification. Next: M6.6 corpse/decay integration.
M6.6 implemented (2026-09-27): [ADR-0056](adr/0056-environmental-terminal-decay.md)
adds explicit terminal facts, retained corpse accounts, shared integer decay caps,
N/P mineralization and organic-energy heat release. Rules/envelope v2 restore
partial inventory, lifecycle and retry reports together; v1 stays byte-compatible.
Tests cover rollback, water headroom, shared caps, restored exact retries, history
eviction, malformed v2 envelopes and next-tick nutrient-fed growth. Next: M6.7
fixed environment interval scheduling; M6.8 retains the full integration proof.
+8 -2
View File
@@ -7,7 +7,7 @@ persistent simulation server. The founding vision remains unchanged.
## Completed implementation
- Vision, architectural pillars, risks, open-question register, architecture
diagrams, biological contracts, engineering constitution and 55 ADRs (including the accepted M6.5 persistence and process contracts).
diagrams, biological contracts, engineering constitution and 56 ADRs (including the accepted M6.6 terminal/decay contract).
Proposed/deferred choices remain distinct from accepted proof decisions.
- M0–M4 task breakdowns with dependencies, acceptance evidence and risks,
plus M5–M14 gates in [ROADMAP.md](ROADMAP.md).
@@ -61,7 +61,7 @@ for the bounded proof; the general production ECS remains a later measured choic
| Priority | Work | Completion evidence |
|---|---|---|
| 1 | M6.6 return dead biomass to environment | Terminal actors cannot act; bounded, conserved decay with persistent residuals and retry safety |
| 1 | M6.7 schedule local environment intervals | Explicit fixed intervals and phase order, bounded catch-up, pause/resume and stale boundary refusal |
| Research | Improve aggregate fidelity and measure Linux/target-host costs | M4.6 found no qualifying width; see the aggregate budget report |
| 2 | Revisit the ADR-0031/0032 reproduction cost model | Reproduction is affordable only at the genome schema's floor; decide whether that is intended before M4 builds cohorts on it |
| Delivery gate | Add/update the dev workload when a deployable increment needs it; Argo is ready | Observe Job/pod completion separately from image publication; no World0 changes |
@@ -722,3 +722,9 @@ required delivery check, not an observed pass.
Next: M6.6 terminal events, retained corpse biomass and bounded decomposition.
No maintenance, reproduction, player progression, simulation version or deployment
changed in this qualification segment.
M6.6 now retains corpse resources and lifecycle in opt-in rules/envelope v2.
Partial bounded decay conserves matter and energy, restores with exact retry
history, and can supply the surviving producer on a later tick. V1 compatibility
is retained. See ADR-0056 and VALIDATION.md for scope and evidence. This does not
add mortality causes, decomposer kinetics, durable publication or player sessions.
@@ -0,0 +1,60 @@
# ADR-0056: Retained environmental corpses and bounded decay
## Status
Accepted for the M6.6 synthetic fixture, 2026-09-27. Rules 2 extend ADR-0055;
rules 1 and their canonical envelope remain supported without reinterpretation.
## Context
Death must not erase inventory or permit further feeding/growth. Lifecycle,
remaining corpse balances and retries must commit together. ADR-0027 establishes
retained accounts and bounded decay for M2; M6 requires tagged destinations.
## Decision
Input carries two terminal flags, producer then consumer, each 0/1. These are
trusted host facts, not client kill requests or a mortality model. Reject a flag
for an already terminal account on a new tick. Retained exact retries still return
their original report. Apply facts before capture/growth and feeding. A bite
involving either terminal actor rejects the entire tick, including pending deaths.
Emptying a producer by feeding still terminates it.
Keep the original account and capacities, including after it empties. There is no
new spendable corpse copy or resurrection. Read-only balances plus terminal flags
identify corpse inventory. Ten explicit integer per-tick decay caps, default zero,
use field order and are shared across corpses in ascending ID order (producer,
consumer). Unused quota expires; unprocessed inventory survives. These are whole
bounded transfers, not fractional kinetics. There is no decay backlog or fractional
clock. Source/growth rational residuals retain their existing meaning.
Decay runs last. Source fields 0..9 return to environment fields
0,1,2,3,1,2,6,9,8,9 respectively: organic N/P mineralize; organic energy becomes
heat; other compartments keep their tags. Carbon remains prepaid organic carbon.
Water return is additionally bounded by habitat water headroom; residual water
stays in the corpse. Source-channel caps are independent. This gate does not decay
environmental waste or imply decomposer kinetics/reactants. Returned nutrients
become available to growth on the following tick.
Reports include consumer transition and ten summed corpse debits in source field
order. Publish via the existing atomic resource checkpoint. Envelope v2 records
caps, both lifecycle states, terminal inputs and decay reports in its replay audit.
Format must match rules. No in-place migration or automatic organism replacement.
## Alternatives Considered
Deleting accounts loses matter. Separate corpse inventories duplicate ownership.
Fractional rates add state without a selected kinetic model. Reinterpreting v1
silently changes physics. Integer caps follow the existing scoped M2 contract.
## Benefits
Exact conservation, bounded work, recoverable partial decay and unchanged v1 bytes.
## Costs
Two scoped rules/codec versions and larger bounded receipt storage.
## Risks
Synthetic mineralization is not complete chemistry. ID priority is a fixture
policy, not a fairness rule. Terminal facts need future host validation. Retaining
empty accounts remains bounded to two actors.
## Consequences
Test pending-death rollback, inactive actors, shared caps, water blocking, partial
decay/restore, retries, malformed envelopes, history eviction and nutrient-fed
regrowth. Durable publication remains M7; M6.7 schedules intervals.
+2
View File
@@ -1,5 +1,7 @@
# Architecture decision records
- [ADR-0056: Environmental terminal decay](0056-environmental-terminal-decay.md) - accepted for M6.6 retained corpses, bounded decay and rules/envelope v2.
Locked requirements outrank these records. Review architecture, ADRs, public
contracts, tests, then implementation. Stop expanding implementation on conflict.
+8
View File
@@ -1,5 +1,13 @@
# M6.5 environmental process contract v1
M6.6 adds opt-in rules 2 under [ADR-0056](../adr/0056-environmental-terminal-decay.md).
The public config adds decay[10] in fg/pJ per tick; input adds terminal[2] flags
in actor order. Progress adds consumer_terminal; reports add consumer_transition
and decomposed[10] source-channel totals. Terminal facts precede capture/growth,
then feeding, then bounded corpse decay. Original accounts retain remaining
inventory. All phases share one rollback and persisted retry boundary. The v1
contract below and its bytes remain unchanged. See the envelope schema for v2.
Authority: ADR-0055, ADR-0054, environmental units (ADR-0050), and the scoped
producer/feeding rules (ADRs 0025/0026). **Implemented in M6.5c; natively qualified in M6.5d.** M6.5b is a
contract segment. M6.5c implements the runtime and complete buffer codec together.
+32
View File
@@ -1917,3 +1917,35 @@ Executed Windows checks:
Native M6.5 qualification is complete; no new Linux/UBSan/TSan or R730xd/cluster
run was available locally. CI must confirm the committed test on its toolchains.
No source-rule, schema, golden or deployment change.
## M6.6 retained corpse resources - 2026-09-27
Rules/envelope v2 now support trusted terminal facts for either fixture actor,
retained corpse inventory and bounded tagged decay. This is an in-memory process
checkpoint, not durable region publication or gameplay mortality. Rule v1 and its
canonical bytes are preserved; no golden was replaced. Config/input extensions
are rejected under v1 rather than silently omitted.
New tests cover pending death plus feeding rollback, terminal actor rejection,
shared per-channel caps in ID order, exact transfer destinations, partial decay,
zero caps, water headroom, restored duplicate/conflicting/stale requests, permanent
terminal state, consumer-corpse nutrients feeding a surviving producer next tick,
every v2 byte truncation, and checksum-repaired invalid lifecycle/history fields.
Eight 90-tick cases compare retained balances against independent cumulative-quota
formulas, with restore at ticks 17, 65 and 90 and exact conservation every tick.
Commands: tools/windows-check.ps1 -Preset release/analysis/asan -Action check;
-Preset release -Action format; git diff --check. The initial suites found the
older negative test's rules=2 was now valid; it now rejects unsupported rules=3.
Final results are recorded below after all processes complete.
Release long qualification again ran 16 x 65536 logical ticks, 2097152 paired
advances, and produced unchanged v1 fingerprint 93a9f9b296caac36. Snapshot size
remains 30615 bytes in that v1 case. Owner size is now 20152 bytes (formerly13400),
including bounded extension receipts; budget admission uses sizeof dynamically.
No new Linux/UBSan/TSan or R730xd measurement is claimed. Linux CI remains a
separate verification step; local Docker Linux engine/toolchain is unavailable.
Final native validation: Release 54/54 (3.66s), clang-tidy analysis 54/54 (13.37s),
ASan 54/54 (46.72s), format check and git diff --check passed. M6.6 is natively
qualified; the next gate is M6.7 interval scheduling. No deployment was changed.
@@ -9,22 +9,27 @@ struct EnvironmentalConfig {
std::array<std::uint64_t, 5> recipe{}, intake{};
std::uint64_t assimilation{}, producer_min_mK{}, producer_max_mK{}, consumer_min_mK{},
consumer_max_mK{};
std::array<std::uint64_t, 10> decay{}; // Rules 2: shared source-channel caps per tick.
auto operator<=>(const EnvironmentalConfig&) const = default;
};
struct EnvironmentalInput {
std::uint64_t temperature_mK{}, source_enabled{};
std::array<std::uint64_t, 5> bite{};
std::array<std::uint64_t, 2> terminal{}; // Rules 2: trusted host facts, actor order.
auto operator<=>(const EnvironmentalInput&) const = default;
};
struct EnvironmentalProgress {
std::uint64_t tick{}, source_remainder{}, last_funded{}, efficiency_remainder{},
growth_remainder{}, producer_terminal{};
std::uint64_t consumer_terminal{};
auto operator<=>(const EnvironmentalProgress&) const = default;
};
struct EnvironmentalReport {
std::uint64_t tick{}, captured{}, retained{}, capture_heat{}, grown{}, unmet{}, source_status{};
std::array<std::uint64_t, 5> assimilated{}, waste{};
std::uint64_t terminal_transition{};
std::uint64_t consumer_transition{};
std::array<std::uint64_t, 10> decomposed{};
auto operator<=>(const EnvironmentalReport&) const = default;
};
enum class CommunityError : std::uint8_t {
+16
View File
@@ -1,5 +1,21 @@
# Environmental community envelope v1 (M6.5c)
## Version 2 extension (M6.6, ADR-0056)
Format 2 requires rules 2; format 1 requires rules 1. The v1 layout below is
unchanged. In v2 append decay[10] to config (39 u64 total), consumer_terminal
to each progress (7 u64; anchor 37 u64), terminal[2] after each input's bite,
and consumer_transition plus decomposed[10] after each report's terminal_transition.
Each v2 receipt is 38 u64 (304 bytes). Fixed overhead is 712 bytes plus receipts
and nested resource bytes. Lifecycle flags are 0/1; decomposed uses source field
order. Both versions replay their own rules. V1 rejects nonzero extension fields
at creation/input validation; they are not silently omitted. No conversion API.
Terminal accounts may retain balances in v2; v1 retains its empty-terminal rule.
Caps are whole fg/pJ per tick, not rates requiring fractional carry. Remaining
corpse inventory resides in nested resource accounts, never duplicated here.
## Version 1 layout
Authority ADR-0055. All integers little-endian, no native struct serialization.
Header u64 magic 0x3150434f564541, u64 format=1, u64 total bytes. Maximum 1 MiB.
Then config, current progress, audit anchor, u64 receipt count, chronological
+35 -18
View File
@@ -38,7 +38,7 @@ struct Reader {
return v;
}
};
template <class T, class IO> void config_io(T& c, IO& io) {
template <class T, class IO> void config_io(T& c, IO& io, bool extended) {
io(c.rules);
io(c.world);
io(c.frame);
@@ -62,29 +62,37 @@ template <class T, class IO> void config_io(T& c, IO& io) {
io(c.producer_max_mK);
io(c.consumer_min_mK);
io(c.consumer_max_mK);
if (extended)
for (auto& v : c.decay)
io(v);
}
template <class T, class IO> void progress_io(T& p, IO& io) {
template <class T, class IO> void progress_io(T& p, IO& io, bool extended) {
io(p.tick);
io(p.source_remainder);
io(p.last_funded);
io(p.efficiency_remainder);
io(p.growth_remainder);
io(p.producer_terminal);
if (extended)
io(p.consumer_terminal);
}
template <class T, class IO> void state_io(T& s, IO& io) {
template <class T, class IO> void state_io(T& s, IO& io, bool extended) {
for (auto& v : s.environment)
io(v);
for (auto& v : s.producer)
io(v);
for (auto& v : s.consumer)
io(v);
progress_io(s.progress, io);
progress_io(s.progress, io, extended);
}
template <class T, class IO> void history_io(T& h, IO& io) {
template <class T, class IO> void history_io(T& h, IO& io, bool extended) {
io(h.input.temperature_mK);
io(h.input.source_enabled);
for (auto& v : h.input.bite)
io(v);
if (extended)
for (auto& v : h.input.terminal)
io(v);
auto& r = h.report;
io(r.tick);
io(r.captured);
@@ -98,27 +106,32 @@ template <class T, class IO> void history_io(T& h, IO& io) {
for (auto& v : r.waste)
io(v);
io(r.terminal_transition);
if (extended) {
io(r.consumer_transition);
for (auto& v : r.decomposed)
io(v);
}
}
} // namespace
std::expected<world::WorldBytes, CommunityError> EnvironmentalCommunity::snapshot() const {
auto resource = resources_->snapshot();
if (!resource)
return std::unexpected{CommunityError::resources};
const auto length =
24 + 29 * 8 + 6 * 8 + 36 * 8 + 8 + count_ * 25 * 8 + 8 + resource->size() + 8;
const bool extended = config_.rules == 2;
const auto length = (extended ? 712 : 616) + count_ * (extended ? 304 : 200) + resource->size();
if (length > max_snapshot_bytes)
return std::unexpected{CommunityError::budget};
Writer w;
w.bytes.resize(length);
w(magic);
w(1);
w(config_.rules);
w(length);
config_io(config_, w);
progress_io(progress_, w);
state_io(anchor_, w);
config_io(config_, w, extended);
progress_io(progress_, w, extended);
state_io(anchor_, w, extended);
w(count_);
for (std::size_t i = 0; i < count_; ++i)
history_io(history_[(next_ + history_limit - count_ + i) % history_limit], w);
history_io(history_[(next_ + history_limit - count_ + i) % history_limit], w, extended);
w(resource->size());
std::copy(resource->begin(), resource->end(),
w.bytes.begin() + static_cast<std::ptrdiff_t>(w.at));
@@ -136,7 +149,9 @@ EnvironmentalCommunity::restore(std::span<const std::uint8_t> bytes, world::Worl
Reader r{bytes.first(bytes.size() - 8)}, tail{bytes.last(8)};
if (r.get() != magic)
return std::unexpected{CommunityError::format};
if (r.get() != 1)
const auto version = r.get();
const bool extended = version == 2;
if (version != 1 && version != 2)
return std::unexpected{CommunityError::version};
if (r.get() != bytes.size())
return std::unexpected{CommunityError::format};
@@ -145,16 +160,18 @@ EnvironmentalCommunity::restore(std::span<const std::uint8_t> bytes, world::Worl
if (budget < sizeof(EnvironmentalCommunity) + scratch_bytes)
return std::unexpected{CommunityError::budget};
auto o = std::unique_ptr<EnvironmentalCommunity>(new EnvironmentalCommunity);
config_io(o->config_, r);
progress_io(o->progress_, r);
state_io(o->anchor_, r);
config_io(o->config_, r, extended);
if (o->config_.rules != version)
return std::unexpected{CommunityError::version};
progress_io(o->progress_, r, extended);
state_io(o->anchor_, r, extended);
const auto count = r.get();
if (!r.ok || count != std::min(o->progress_.tick, std::uint64_t{history_limit}) ||
o->anchor_.progress.tick != o->progress_.tick - count ||
count * 200 > r.bytes.size() - r.at)
count * (extended ? 304 : 200) > r.bytes.size() - r.at)
return std::unexpected{CommunityError::format};
for (std::size_t i = 0; i < count; ++i) {
history_io(o->history_[i], r);
history_io(o->history_[i], r, extended);
if (o->history_[i].report.tick != o->anchor_.progress.tick + i + 1)
return std::unexpected{CommunityError::format};
}
+40 -5
View File
@@ -15,7 +15,9 @@ std::uint64_t portion(std::uint64_t x, std::uint64_t a) {
} // namespace
bool EnvironmentalCommunity::configuration(const EnvironmentalConfig& c,
const world::EnvironmentalTransfers& r) noexcept {
if (c.rules != 1 || c.world == 0 || c.frame == 0 ||
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 ||
r.fields().identity() != world::WorldIdentity{c.world, c.frame} || c.source == 0 ||
c.tick_microseconds == 0 || c.area_um2 == 0 || c.irradiance_denominator == 0 ||
c.growth_denominator == 0 || c.efficiency > 1000 || c.assimilation > 1000 ||
@@ -51,10 +53,12 @@ bool EnvironmentalCommunity::valid(const State& s) const noexcept {
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.last_funded > p.tick || p.producer_terminal > 1 ||
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{}))
return false;
if (p.producer_terminal && std::ranges::any_of(s.producer, [](auto v) { return v != 0; }))
if (config_.rules == 1 && p.producer_terminal &&
std::ranges::any_of(s.producer, [](auto v) { return v != 0; }))
return false;
if (s.environment[0] > resources_->fields().water_capacity(0)->value)
return false;
@@ -98,6 +102,18 @@ EnvironmentalCommunity::step(State& s, std::uint64_t tick,
const auto& c = config_;
EnvironmentalReport report{};
report.tick = tick;
if (input.terminal[0] > 1 || input.terminal[1] > 1 ||
(c.rules == 1 && (input.terminal[0] || input.terminal[1])) ||
(input.terminal[0] && p.producer_terminal) || (input.terminal[1] && p.consumer_terminal))
return std::unexpected{CommunityError::input};
if (input.terminal[0]) {
p.producer_terminal = 1;
report.terminal_transition = 1;
}
if (input.terminal[1]) {
p.consumer_terminal = 1;
report.consumer_transition = 1;
}
const bool eligible = !p.producer_terminal && input.temperature_mK >= c.producer_min_mK &&
input.temperature_mK <= c.producer_max_mK;
if (eligible && input.source_enabled) {
@@ -150,8 +166,8 @@ EnvironmentalCommunity::step(State& s, std::uint64_t tick,
report.unmet = quota->amount.value - grown;
}
if (any(input.bite)) {
if (p.producer_terminal || input.temperature_mK < c.consumer_min_mK ||
input.temperature_mK > c.consumer_max_mK)
if (p.producer_terminal || p.consumer_terminal ||
input.temperature_mK < c.consumer_min_mK || input.temperature_mK > c.consumer_max_mK)
return std::unexpected{CommunityError::input};
for (std::size_t j = 0; j < 5; ++j) {
const auto amount = input.bite[j], k = food[j];
@@ -173,6 +189,25 @@ EnvironmentalCommunity::step(State& s, std::uint64_t tick,
report.terminal_transition = 1;
}
}
if (c.rules == 2) {
constexpr std::array<std::size_t, 10> destination{0, 1, 2, 3, 1, 2, 6, 9, 8, 9};
auto remaining = c.decay;
for (std::size_t actor = 0; actor < 2; ++actor) {
if (!(actor == 0 ? p.producer_terminal : p.consumer_terminal))
continue;
auto& corpse = actor == 0 ? s.producer : s.consumer;
for (std::size_t k = 0; k < 10; ++k) {
auto amount = std::min(remaining[k], corpse[k]);
if (k == 0)
amount = std::min(amount, resources_->fields().water_capacity(0)->value -
s.environment[0]);
corpse[k] -= amount;
s.environment[destination[k]] += amount;
remaining[k] -= amount;
report.decomposed[k] += amount;
}
}
}
p.tick = tick;
if (!valid(s))
return std::unexpected{CommunityError::resources};
+177 -1
View File
@@ -34,7 +34,7 @@ EnvironmentalConfig config() {
}
std::unique_ptr<EnvironmentalTransfers>
resources(std::array<std::uint64_t, 10> e = {100, 100, 100, 100, 0, 0, 100, 0, 10, 0},
std::array<std::uint64_t, 10> p = {}) {
std::array<std::uint64_t, 10> p = {}, std::array<std::uint64_t, 10> consumer = {}) {
const FieldSite site{{0, 0, -16000}, {{0}, {0}, {0}, {10}, {20}, {3}}, {1}};
std::array<FieldOpening, 10> opening{};
for (std::size_t k = 0; k < 10; ++k)
@@ -50,6 +50,7 @@ resources(std::array<std::uint64_t, 10> e = {100, 100, 100, 100, 0, 0, 100, 0, 1
accounts[0].id = {1};
accounts[1].id = {2};
accounts[0].balances = p;
accounts[1].balances = consumer;
for (auto& a : accounts)
a.capacities.fill(1000);
auto r =
@@ -233,12 +234,187 @@ void codec_replay() {
CHECK(!EnvironmentalCommunity::restore(corrupted, identity, 8000000));
CHECK(o->snapshot() == saved);
}
void terminal_decay() {
auto c = config();
c.rules = 2;
c.decay.fill(3);
const std::array<std::uint64_t, 10> stock{5, 5, 5, 5, 5, 5, 5, 5, 5, 5};
auto created = EnvironmentalCommunity::create(c, resources({}, stock, stock), 8000000);
CHECK(created);
auto o = std::move(*created);
const auto total = audit(*o);
const auto before = o->snapshot();
CHECK(before);
// A pending terminal fact invalidates feeding and rolls back the entire tick.
for (auto facts : {std::array<std::uint64_t, 2>{1, 0}, std::array<std::uint64_t, 2>{0, 1}}) {
CHECK(!o->advance(1, {290000, 1, {1, 0, 0, 0, 0}, facts}));
CHECK(o->snapshot() == before);
}
CHECK(!o->advance(1, {290000, 0, {}, {2, 0}}));
const EnvironmentalInput death{290000, 1, {}, {1, 1}};
auto report = o->advance(1, death);
CHECK(report);
CHECK(report->terminal_transition == 1 && report->consumer_transition == 1);
CHECK(report->captured == 0 && report->grown == 0);
for (std::size_t k = 0; k < 10; ++k) {
CHECK(report->decomposed[k] == 3);
CHECK(o->resources().organisms()[0].balances[k] == 2);
CHECK(o->resources().organisms()[1].balances[k] == 5);
}
const std::array<std::uint64_t, 10> returned{3, 6, 6, 3, 0, 0, 3, 0, 3, 6};
for (std::size_t k = 0; k < 10; ++k)
CHECK(o->resources().fields().read(0, static_cast<Field>(k)) == returned[k]);
CHECK(audit(*o) == total);
auto saved = o->snapshot();
CHECK(saved);
auto restored = EnvironmentalCommunity::restore(*saved, identity, 8000000);
CHECK(restored);
CHECK((*restored)->snapshot() == saved);
CHECK((*restored)->advance(1, death) == report);
CHECK(!(*restored)->advance(1, {290000, 0, {}, {1, 1}}));
CHECK(!(*restored)->advance(2, death)); // repeated death on a fresh tick
CHECK(!(*restored)->advance(2, {290000, 0, {1, 0, 0, 0, 0}}));
CHECK((*restored)->snapshot() == saved);
for (std::uint64_t t = 2; t <= 70; ++t) {
const EnvironmentalInput input{290000, 1, {}};
auto r = o->advance(t, input);
CHECK(r && (*restored)->advance(t, input) == r);
CHECK(audit(*o) == total);
CHECK(o->snapshot() == (*restored)->snapshot());
for (auto debit : r->decomposed)
CHECK(debit == (t < 4 ? 3 : t == 4 ? 1 : 0));
if (t == 2) {
CHECK(o->resources().organisms()[0].balances == std::array<std::uint64_t, 10>{});
CHECK(o->resources().organisms()[1].balances[4] == 4);
}
}
saved = o->snapshot();
CHECK(saved);
restored = EnvironmentalCommunity::restore(*saved, identity, 8000000);
CHECK(restored && (*restored)->snapshot() == saved);
CHECK(!(*restored)->advance(1, death)); // retired receipt cannot decay again
CHECK((*restored)->progress().producer_terminal == 1 &&
(*restored)->progress().consumer_terminal == 1);
// Full water destination leaves corpse water intact; zero caps freeze all inventory.
c.decay.fill(0);
auto frozen = EnvironmentalCommunity::create(c, resources({}, stock), 8000000);
CHECK(frozen && (*frozen)->advance(1, {290000, 0, {}, {1, 0}}));
CHECK((*frozen)->resources().organisms()[0].balances == stock);
c.decay.fill(100);
auto blocked = EnvironmentalCommunity::create(
c, resources({999, 0, 0, 0, 0, 0, 0, 0, 0, 0}, stock), 8000000);
CHECK(blocked);
auto r = (*blocked)->advance(1, {290000, 0, {}, {1, 0}});
CHECK(r && r->decomposed[0] == 1);
CHECK((*blocked)->resources().organisms()[0].balances[0] == 4);
r = (*blocked)->advance(2, {290000, 0, {}});
CHECK(r && r->decomposed[0] == 0);
saved = (*blocked)->snapshot();
CHECK(saved);
restored = EnvironmentalCommunity::restore(*saved, identity, 8000000);
CHECK(restored && (*restored)->resources().organisms()[0].balances[0] == 4);
// Consumer corpse supplies missing N/P; growth cannot spend it until the next tick.
c.growth_numerator = 1;
auto regrow = EnvironmentalCommunity::create(c,
resources({10, 0, 0, 20, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 9, 0, 0},
{0, 0, 0, 0, 2, 2, 0, 6, 0, 0}),
8000000);
CHECK(regrow);
const auto regrow_total = audit(**regrow);
r = (*regrow)->advance(1, {290000, 0, {}, {0, 1}});
CHECK(r && r->grown == 0 && r->decomposed[4] == 2 && r->decomposed[7] == 6);
r = (*regrow)->advance(2, {290000, 0, {}});
CHECK(r && r->grown == 1 && audit(**regrow) == regrow_total);
CHECK((*regrow)->resources().organisms()[0].balances[4] == 1);
// Extension data cannot be silently lost through the v1 codec.
c.rules = 1;
CHECK(!EnvironmentalCommunity::create(c, resources(), 8000000));
auto legacy = make();
CHECK(!legacy->advance(1, death));
}
void terminal_codec_validation() {
auto c = config();
c.rules = 2;
c.decay.fill(1);
auto created =
EnvironmentalCommunity::create(c, resources({}, {5, 5, 5, 5, 5, 5, 5, 5, 5, 5}), 8000000);
CHECK(created);
CHECK((*created)->advance(1, {290000, 0, {}, {1, 1}}));
auto saved = (*created)->snapshot();
CHECK(saved);
for (std::size_t n = 0; n < saved->size(); ++n)
CHECK(!EnvironmentalCommunity::restore(std::span{*saved}.first(n), identity, 8000000));
// v2 offsets: config24, progress336, anchor392, count688, first input696,
// terminal flags752/760, report768, consumer transition912, decay920.
for (std::size_t offset :
{std::size_t{8}, std::size_t{24}, std::size_t{384}, std::size_t{680}, std::size_t{688},
std::size_t{752}, std::size_t{760}, std::size_t{912}, std::size_t{920}}) {
auto b = *saved;
b[offset] = 255;
std::uint64_t h = 14695981039346656037ULL;
for (auto v : std::span{b}.first(b.size() - 8))
h = (h ^ v) * 1099511628211ULL;
for (unsigned j = 0; j < 8; ++j)
b[b.size() - 8 + j] = static_cast<std::uint8_t>((h >> (8 * j)) & 255U);
CHECK(!EnvironmentalCommunity::restore(b, identity, 8000000));
}
CHECK((*created)->snapshot() == saved);
}
void decay_continuation() {
for (std::uint64_t sample = 0; sample < 8; ++sample) {
auto c = config();
c.rules = 2;
std::array<std::uint64_t, 10> producer{}, consumer{};
for (std::size_t k = 0; k < 10; ++k) {
producer[k] = 100 + sample * 5 + k * 3;
consumer[k] = 140 + sample + k;
c.decay[k] = (k + sample) % 5;
}
auto created =
EnvironmentalCommunity::create(c, resources({}, producer, consumer), 8000000);
CHECK(created);
auto o = std::move(*created);
const auto total = audit(*o);
for (std::uint64_t t = 1; t <= 90; ++t) {
const EnvironmentalInput input{290000, 0, {}, {t == 3 ? 1U : 0U, t == 3 ? 1U : 0U}};
auto r = o->advance(t, input);
CHECK(r);
CHECK(audit(*o) == total);
for (std::size_t k = 0; k < 10; ++k) {
// Closed-form cumulative quota, independent of runtime per-tick recurrence.
const auto quota = (t > 2 ? t - 2 : 0) * c.decay[k];
const auto first = quota < producer[k] ? producer[k] - quota : 0;
const auto second_quota = quota > producer[k] ? quota - producer[k] : 0;
const auto second = second_quota < consumer[k] ? consumer[k] - second_quota : 0;
CHECK(o->resources().organisms()[0].balances[k] == first);
CHECK(o->resources().organisms()[1].balances[k] == second);
}
if (t == 17 || t == 65 || t == 90) {
auto bytes = o->snapshot();
CHECK(bytes);
auto restored = EnvironmentalCommunity::restore(*bytes, identity, 8000000);
CHECK(restored);
CHECK((*restored)->snapshot() == bytes);
CHECK((*restored)->advance(t, input) == r);
CHECK((*restored)->snapshot() == bytes);
o = std::move(*restored);
}
}
}
}
} // namespace
int main() {
try {
vectors();
rollback_limits();
codec_replay();
terminal_decay();
terminal_codec_validation();
decay_continuation();
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
+1 -1
View File
@@ -116,7 +116,7 @@ void refusals() {
auto c = config();
switch (which) {
case 0:
c.rules = 2;
c.rules = 3; // Rules 2 are the M6.6 terminal/decay extension.
break;
case 1:
c.world = 8;