Commit Graph
35 Commits
Author SHA1 Message Date
dingo a479ce2d95 Add cellular genome revision profile migration
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m59s
Foundation / checks (checks) (push) Failing after 2m10s
Foundation / checks (postgres) (push) Failing after 10m34s
Foundation / checks (network) (push) Failing after 12m19s
Foundation / checks (tsan) (push) Failing after 2m14s
Foundation / checks (client) (push) Successful in 15m7s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
2026-10-11 06:13:17 -04:00
dingoandClaude Opus 5.5 17fe23e5f0 M11.1: genome schema 2 with per-second rates (ADR-0099, segment 2)
Foundation / checks (deploy) (push) Successful in 3m32s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (client) (push) Successful in 12m56s
Foundation / checks (network) (push) Successful in 13m46s
Foundation / checks (tsan) (push) Successful in 7m59s
Foundation / checks (checks) (push) Successful in 33m36s
Foundation / checks (postgres) (push) Successful in 45m30s
Foundation / postgres-tools (push) Successful in 20s
Foundation / server-image (push) Successful in 25s
Foundation / image (push) Successful in 2m36s
Movement and ingestion are stored per second in schema 2 (ranges x20). Schema 1 records
stay valid, are never rewritten, and read as exactly x20 via Genome::per_second; drafts
default to schema 1 so existing literals keep their meaning. Development version 1
converts genome rates at its own 50 ms quantum (round down), so phenotypes are
unchanged. Mutation keeps the parent's schema and step; the lineage archive header names
exactly the highest schema held (all-schema-1 archives keep their bytes); the
development-v1 opening names schema 1. No golden changed; two tests that used 2 as an
unknown schema now use the next one. Refresh the dev session window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 13:16:55 -04:00
dingoandClaude Opus 5.5 c468c70933 M11.1: record the first cellular loop decisions (ADR-0098)
Foundation / checks (checks) (push) Successful in 4s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 5s
Foundation / checks (postgres) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 3m33s
Foundation / postgres-tools (push) Successful in 5s
Foundation / image (push) Successful in 4s
Foundation / server-image (push) Successful in 5s
Maintainer decisions (2026-10-09) for the first playable loop: budding (parent keeps
control, one funded wildlife bud); funded in-life mutation from seeded candidates;
exact-copy heredity, no NPC mutation in M11; logout freezes at once, lingers vulnerable,
then suspends; resume in place or nearest valid spot within a bounded radius;
absorption plus engulfment by membrane-contested size ratio; first bud fundable within a
session (tunable); friend recognition deferred. Updates OPEN_QUESTIONS 7/10/14/31/33,
REPRODUCTION_MODEL, ROADMAP, STATUS; BACKLOG gains the open M10 native-client items.
Refresh the dev session window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 10:51:23 -04:00
dingoandClaude Opus 5.5 a2c4543df2 Complete M7.4b lineage checkpoint profile; M7.4 done
ADR-0062 adds a canonical LineageArchive codec (parents before children,
organisms by id, FNV) that decodes by replaying admit/record_birth/
record_death and requires byte-identical re-encoding; it never overwrites
an existing archive. LineageRegion binds the environmental producer and
consumer accounts to archived organisms with identity high-waters,
enforces closure (lifecycle vs deaths, exact living set, tick bounds)
and records deaths in the tick that causes them.

Checkpoint profile 2 (environmental-lineage-v1, history profile 1)
publishes that container; schema v4 admits it with a 4,268,144-byte cap
and requires each commit to keep its predecessor's profile, RNG, history
and durability declarations. Linux adds provision/publish/recover for
the profile on the shared publication path.

Qualification found WSL2 stepping CLOCK_REALTIME back ~0.5 s every ~32 s,
which made two 1 s-lease tests flaky under ASan. Tests now wait on
database-time expiry; ADR-0060 records the slewed-clock requirement.

Validated: Windows CTest 57/57; Linux GCC Debug/Release, clang-tidy and
ASan/UBSan CTest 57/57 each; PostgreSQL suites 2x Release, 2x analysis,
5x ASan; SQL and C++ mutations each caught. No Docker/Gitea CI, remote
store, process kill or deployment.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-28 16:43:10 -04:00
dingo ef40f38ed0 Implement M6.7 bounded environmental interval scheduling 2026-09-27 18:45:06 -04:00
dingo 6dd0e49e45 Implement M6.6 retained corpses and versioned bounded decay 2026-09-27 18:37:36 -04:00
dingo 6fd553c84b Qualify M6.5 environmental fixture with boundary and long-run tests 2026-09-27 13:57:01 -04:00
dingo 364c090bc8 Implement M6.5c persisted environmental community and bounded writers 2026-09-27 13:07:35 -04:00
dingo e9ea388cef Define M6.5b environmental process conversions and ownership 2026-09-27 09:39:51 -04:00
dingo 70cd288327 Complete M6.4 atomic environmental transfers 2026-09-27 09:15:21 -04:00
dingo ab130b0fbb Complete M6.2 optional finite environmental fields 2026-09-27 00:21:05 -04:00
dingo 750afcd4d4 Complete M6.1 environmental units and coupling contract 2026-09-27 00:06:24 -04:00
dingo 8b5bf48795 Implement M5.5 atomic terrain excavation and debris accounting 2026-09-26 14:56:44 -04:00
dingo c237e4da97 Measure aggregate cost and fidelity across scarcity scenarios 2026-09-26 09:39:53 -04:00
dingoandClaude Opus 5 b4c3da56e9 Four of five runs conserve perfectly; three are ecologically worthless
M4.5 closes M4 by measuring what aggregation costs, and adds no library code
except one defect fix the measurement found.

One rule is written once and applied at both resolutions. The control is what
makes the rest mean anything: with one member per class a class average is that
member, so the two runs must agree exactly, and they do, tick by tick, in every
channel. A deliberate one-unit drift in the aggregate rule is caught by it, so the
instrument is verified rather than assumed. Without it a measured gap would be
indistinguishable from a transcription mistake in one of the two runs.

The result is reported, not smoothed into a tolerance. At class widths ten and
fifty the aggregate population survives ten thousand ticks within 375 parts per
thousand on population and 43 on energy. At twenty-five, one hundred and two
hundred it dies out entirely while the individual run sustains seventy-five
members: a false extinction caused by resolution alone, because a whole class
starves the moment its average cannot pay upkeep, where individuals starve a few
at a time and the survivors keep the shared per-capita share up.

The collapse is not monotone in class width. Twenty-five destroys the population
and fifty sustains it. An earlier version of the test asserted that coarser is
never better; the measurement refuted it, so the assertion went rather than the
widths being chosen to make it hold. The non-monotonicity is asserted now, because
it is surprising and because the warning written around it could otherwise become
wrong without failing. A tier policy cannot assume degradation worsens smoothly as
classes widen, and M4.6 inherits that.

Conservation was exact at every tick on both sides of all five runs, including the
three that died out. That is the clearest available demonstration of the thing
ECOLOGY_MODEL keeps saying: conservation is not ecological evidence.

Two flaws in my own experiment were found before any number was believed. The
aggregate model had been producing overlapping classes, so the model measured was
not one a cohort could represent; newborns now extend the youngest class while it
is narrower than the width, and every step is checked to construct a valid Cohort.
The first figures were discarded.

The comparison also found a real M4.3 defect, which is what a validation milestone
is for. plan_advance checked affordability with arrivals added before losses were
taken, but emitted the ledger legs outflows-first, so an interval affordable as a
whole underflowed leg by leg and was refused at commit. A fifty-tick interval
shedding 10,480 against 6,950 held while drawing 13,080 in reproduced it. Arrivals
are the first leg now, matching the order the arithmetic was checked in, with a
regression and a corrected escrow expectation in an existing test.

Release 38/38, analysis, ASan 38/38 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 21:57:00 -04:00
dingoandClaude Opus 5 14e0c1af5e An empty reservoir is not an unowned one
Two defects from review of 380d609.

Materialization treated an empty reservoir as available. A vacant cohort, or one
holding nothing, still owns its store, so a draw could credit it while the owning
record went on recording nothing: the same inventory in two places, reached from
the opposite direction to the destination defect in 1a59b63. Destinations are
checked against the registry's ownership now, not just their balance, and the
registry answers whether a reservoir is used rather than callers inferring it from
what the reservoir contains.

The same hole existed on the collapse side in a worse form, found by asking
whether the reported defect had a sibling. Nothing verified the destination was
unowned, so the shared-reservoir rule added in M4.3 would have refused the install
only after the transfer had run, leaving the members emptied and their biomass in
a reservoir nothing accounted for. That is exactly the stranding the M4.2 ordering
was chosen to prevent, defeated by a check that ran too late. Whichever registry
step follows a transfer is now proved to succeed before it, through may_install
and may_replace queries that install and replace delegate to, so there is one rule
and not a restatement that can drift.

The second finding was a functional gap the oscillation test hid by discarding its
registry each cycle. A full draw leaves a vacant record, which ADR-0036 retains
because absence is not extinction, and collapse then refused that habitat and
genome as occupied: a full materialization was a one-way door out of a habitat and
the lineage could never return. Collapse repopulates a vacant record in place now,
continuing its ownership and revision series rather than restarting them, and a
record still holding a population is refused, because merging two silently is not
a conversion. The test keeps one registry for all twelve cycles and asserts the
revision continues.

Four of the five new guards are load-bearing. The fifth is not and is recorded as
such: the may_replace pre-check in commit_materialize is unreachable given the
checks before it, since the installed record is already proved equal to the plan's
origin and the result differs only by a later revision. It is kept because it is
the right place for the guard and its collapse-side sibling is genuinely
reachable, not because it is exercised.

Release 37/37, analysis, ASan 37/37 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 17:47:37 -04:00
dingoandClaude Opus 5 380d609f06 Round shares down and ages up, so a round trip never pays
M4.4 turns whole members of a cohort back into identified individuals, and does
nothing else: no habitat transfer, no persistence, no resolution-equivalence
claim. Materialization is instantaneous at the cohort's current tick, because
advancing time is M4.3's interval.

The named risk is that re-materialization becomes free healing, and it has two
separable sources. The arithmetic one is closed outright. A drawn member gets its
class share by integer division rounded down, because rounding up would create
biomass, and a class drawn empty hands over everything it held because a class
with no members may keep no reserve. A residual is never drawable, so an expected
density cannot become an individual.

Age is taken as the oldest the class admits. The exact age is unrecoverable, so
the question is only which direction to be wrong in, and every other answer makes
oscillation profitable: a member re-materialized at the bottom of its class is
younger than it was, and repeating that is immortality. Taking the top means a
round trip can only age someone. Both of these are the risk rather than ordinary
validation, and both mutations are detected: rounding the share up, and drawing
the age from the class floor.

The second source is the declared resolution itself and is stated rather than
mitigated. Members inside a class are indistinguishable by construction, so
collapsing a starving member with a well-provisioned one and materializing both
returns two average members, healing the first at the second's expense. The tests
demonstrate both halves instead of only the flattering one: a round trip is exact
when each class holds one member, and a coarse class conserves the total while
averaging the individuals. Conservation of the total is not evidence that any
individual is right, and the mitigation is the caller's choice of classes when it
collapses, not anything this code can recover.

Materialization produces exactly the record a collapse consumes, so the two
compose and are tested against each other rather than described as inverses. The
oscillation test runs twelve cycles and asserts every cycle that the conserved
total never moves, nobody holds more than the richest starting member held, and
nobody is younger than last cycle; it ends by asserting everyone has been pushed
to a class ceiling, which records the cost of the age rule rather than claiming
it away.

Release 37/37, analysis, ASan 37/37 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 15:41:49 -04:00
dingoandClaude Opus 5 cabada70c4 Account for the interval a model proposes; never clamp it
M4.3 advances a cohort over one declared interval and deliberately does not model
one. ECOLOGY_MODEL keeps population maths an experiment and asks for several
candidates to be compared, so choosing one here would turn a recommendation into
a locked rule. A model proposes fluxes; this checks the declared result is
exactly what they imply, for counts and for every inventory channel.

Nothing is clamped. A loss larger than what is there refuses the interval and
says whether it was the population or the biomass, so a caller can subdivide;
subtraction is checked against what is present rather than performed and
repaired, so a negative population is never constructed. That is the answer to
the named risk: a clamp is how an interval a model could not integrate becomes a
plausible result, and how a false extinction arrives. Both clamp mutations are
detected by the tests.

Counts carry whole members and owed fractions as one quantity, so a population
below one member is a number rather than a rounding decision. Biomass has no
birth term at all, so a birth cannot bring inventory in and newborns are
necessarily funded from what the cohort holds. Immigration draws from a reservoir
that already held it, so a late transfer is not new production. Conservation runs
through the ledger as one atomic transaction; an interval where nothing moves
submits none.

Two amendments to M4.1 were forced, not chosen. A cohort records the reservoir
backing it, because an advance cannot otherwise know where the inventory is and
passing it alongside would let a caller advance one cohort against another's
store, which comparing balances cannot detect between equal reserves; the
registry now refuses two cohorts sharing one. And a cohort may be vacant, through
a separate factory so vacancy stays deliberate, because a decline to exactly zero
was otherwise unrepresentable and the only way through would have been the clamp
this milestone exists to refuse. A vacant cohort is not an extinction: the
record, its genome, its habitat and its provenance remain and it stays installed.

Fourteen guards confirmed load-bearing by removing each and rerunning. Two of my
own expectations were wrong rather than the code: escrow arithmetic in the
migration test, and a dwindling case that shed all but one femtogram while
declaring a result holding none. The second surfaced a real tension now recorded
in ADR-0038 rather than worked around: a class reduced to a fraction of a member
may hold no reserve, because reserve belongs to members and a fraction is not one
yet, so that biomass has to go somewhere the same interval.

Closure is checked and stability is not, so an interval whose arithmetic balances
and whose ecology is nonsense is accepted. The declared age structure is not
verified to be what ageing would produce, because that needs the within-class
distribution the record discards.

Release 36/36, analysis, ASan 36/36 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 10:23:09 -04:00
dingoandClaude Opus 5 0697895e25 A cohort's reserve is the whole of its reservoir, not a part of it
Commit proved the destination reservoir existed and that the registry slot was
free, but never that the reservoir was empty. Gathering into an occupied
reservoir therefore succeeded and mixed inventory the conversion had never
sampled into the cohort's backing store: the cohort's recorded reserve
understated what backed it, and the surplus belonged to nobody.

Reproduced against the unfixed code rather than taken on trust. Gathering into
reservoir 5, which the fixture already seeds with seven picojoules, commits and
leaves the ledger holding 67 against a cohort recording 60, exactly as reported.

A destination holding anything is refused now. The success test also asserts the
destination balance equals the installed cohort's reserve, so the equality is
checked rather than assumed, and the regression asserts the refusal leaves the
balances, the action counter and the registry as they were, then that emptying
the reservoir first makes the same plan committable.

The check runs after the staleness loop rather than beside the other destination
checks. Both run before anything moves, so it is a reporting choice: replaying a
committed plan into a fresh registry would be refused by either, and that the
members no longer hold what was sampled says more than that the reservoir is
occupied.

The guard was confirmed load-bearing by removing it alone. An earlier attempt at
that reported it as not load-bearing; that result was void and discarded, because
a heredoc had mangled the mutation script and nothing was ever mutated. Second
time this quirk has produced a false negative in a sweep, and both times the
printed output rather than the exit status is what caught it.

Release 35/35, analysis, ASan 35/35 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 09:59:39 -04:00
dingoandClaude Opus 5 1a59b63c7a Refuse the whole conversion rather than drop the inconvenient member
M4.2 moves individuals into the M4.1 record and does only that: no advance, no
materialization back, no transfer between habitats, no persistence.

Collapse is two phases over one sample. plan_collapse reads the members once and
returns an immutable plan that already carries a validated cohort; commit applies
exactly that plan and derives nothing, so replaying a committed sample cannot
resample, and a record that would not validate fails during planning rather than
after the ledger has moved.

A controlled, suspended, dead or unsettled member refuses the whole plan instead
of being skipped. Filtering would let a caller obtain a plan by omitting whoever
was inconvenient, and the result would be indistinguishable from an honest
conversion, which is the adversarial selection the model forbids. Ages are
carried into declared classes and a member fitting none refuses the plan, so
nobody is quietly moved or dropped for having nowhere to go. Reserves are summed
per class and never redistributed, so the distribution M4.1 exists to keep
survives the move.

Conservation runs through the ledger rather than beside it: one atomic
transaction, one leg per member, each moving that member's entire reserve, so the
conserved total is unchanged by construction. Dual representation is closed from
both ends. A member must be emptied exactly, and a reservoir holding anything
other than what was sampled makes the plan stale rather than partly applicable.
The destination is proved available before anything moves, so no rejection can
strand biomass in a reservoir nothing owns. Reversing that order is detected by
the tests, which is the point: the ordering prevents the failure rather than a
comment claiming it cannot happen.

Two gaps are stated rather than implied covered. This cannot tell whether the
members offered were all there were, so completeness is the caller's obligation.
And emptying a reservoir is not withdrawing the right to use it, because the
ledger has no removal.

ReservoirId and Transfer gain the defaulted comparisons every other value type
here already has, so a plan's legs can be compared. Additive, and ADR-0037 says
so rather than claiming no M1 change.

All ten guards were confirmed load-bearing by removing each and rerunning. One of
my own expectations was wrong rather than the code: a replayed commit reported
stale_plan where I expected destination_occupied. Both are pure checks made
before anything moves, so only the diagnosis differed; the destination check runs
first now, because "this already happened" says more about a replay.

Release 35/35, analysis, ASan 35/35 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 09:45:09 -04:00
dingoandClaude Opus 5 5a4c34a903 An epoch cannot order two writes an owner makes inside it
Two defects from review of 1c8b292.

Replacement checked the ownership epoch and nothing that ordered two writes made
inside one, so an owner could replay its own earlier record: a cohort installed
at tick 1,000 holding 50 picojoules accepted its own tick-900 record holding 100,
restoring inventory the installed one had already spent. A cohort now carries a
revision that strictly increases within an epoch, and a repeated revision is
refused as well as an older one, because a write has to be strictly later rather
than merely not earlier. A newer epoch may restart the series, since re-acquiring
ownership begins a new one, but the interval boundary is checked independently of
both, so neither advancing a revision nor re-acquiring ownership rewinds
simulated time. A later revision at the same boundary stays legitimate: that is a
correction, not a rewind.

The implicit move emptied a cohort's age classes while keeping its habitat,
genome and owner, so a moved-from record was exactly the invalid cohort create
refuses to build, and the registry accepted through a move what it rejects
through construction. The type is copy-only now, so a move decays to a copy and
the source stays whole. ADR-0030 made the genome copy-only for this same reason
in M3.1; the precedent existed and was not applied when this type was written.

Both fixes were confirmed load-bearing by reverting each alone. Removing either
ordering check fails the new regression. Removing the copy declarations fails to
compile, and not only through the static assertion: with that also removed, MSVC
proves the code after the class-count check unreachable, having established that
a moved-from vector is empty and the check always throws. That is a compile-time
proof rather than an execution, so the runtime path was checked separately under
ASan, where the same mutation exits 1.

Release 34/34, analysis, ASan 34/34 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 09:05:05 -04:00
dingoandClaude Opus 5 1c8b292147 Keep a distribution, because a mean cannot say who survives
M4.1 defines the tier 2 record and who may act on it, and nothing else: no
collapse transaction, no population advance, no materialization, no habitat
geometry. Those are M4.2 to M4.4 and each needs its own decision.

The named risk for this step is that population averages hide viable outliers,
which is a property of the record rather than of the maths applied to it later,
so it is answered here. Age classes each carry their own count and their own
reserve. A count with a mean reserve cannot tell a provisioned cohort from one
where half the members hold nothing, and nothing downstream can recover what
that discarded. Within a class members are indistinguishable; that is the
declared resolution and a stated loss. No accessor returns a mean, because an
average that is easy to reach becomes the authority.

Totals are summed from the classes rather than stored beside them, following the
archive's rule that a second tally is a thing that can disagree. Lineage is not a
field at all: ancestry is resolved from the genome through the archive, so a
cohort cannot contradict it or invent parentage from membership. Residuals are
integer numerators strictly below one member and are never added to a count.

Ownership is enforced rather than described. One record per habitat and genome
makes no-inventory-spendable-in-two-tiers unrepresentable instead of forbidden,
and replacement is refused under a different worker or an older epoch. That is a
single-process invariant; fencing between workers is M7 and M10. The
approximation bound is carried and never computed, since carrying a bound is not
meeting one.

All nine guards were confirmed load-bearing by removing each and rerunning. An
earlier sweep reporting none of them load-bearing was wrong and discarded: it
wrote to /tmp, which Git Bash and PowerShell resolve differently, so nothing was
ever mutated.

Release 34/34, analysis, ASan 34/34 and clang-format all ran and passed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-24 06:14:07 -04:00
dingoandClaude Opus 5 89ad95bf12 Let a genome decide, and report where each axis actually acts
M3.6 joins the M3 pieces: strategy_for derives a StrategyConfig from the
metabolic budget, founders are pre-diverged variants admitted to the lineage
archive, and evo-sim --ensemble runs them over a resource and temperature grid
with every cell's seeds split in half and never merged. ADR-0029's driver is
untouched, so the M2.6 fingerprint still holds. Nothing mutates during an
episode, so NPC mutation stays open.

Three things measurement found, kept rather than smoothed over. The report
aggregates were default-initialized, leaving their scalar counters
indeterminate. The resource level never reaches strategy derivation at all, so
the header now says where each axis acts instead of claiming both shape a
strategy. And the resource axis is not monotonic: a sweep peaks near 8000
femtograms and falls away on both sides, because only one consumer may bite a
target per tick, so scarcity concentrates mass into individuals that reach the
threshold while abundance spreads the same income too thin. The test asserts
that an axis moves the outcome and never a direction; an earlier draft asserted
a direction that held at two cells and the sweep disproves.

Earning a birth at all required pinning the investment fraction to the schema
floor, since intake scales with surface and investment with mass. That is a
finding about the ADR-0031/0032 cost model, now the second priority in STATUS.

Release 33/33, analysis, ASan 33/33 and clang-format all ran and passed here;
no Clang or GCC compile happens on this host, so Linux CI is still the first
result for this increment.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-23 23:03:52 -04:00
dingoandClaude Opus 5 8020347f9b Keep every lineage, and never call absence extinction
M3.5 retains the genomes M3.4 produces and the organisms that carried
them. The named risk is deleting extinct genomes, so the answer is
structural: LineageArchive has no removal operation at all, not a guarded
one and not a private one. Retention is a property of the interface
rather than a rule someone has to remember, which is the only form of
"keep extinct genomes indefinitely" that a later change cannot quietly
undo. Four concepts assert that, with a positive control so the check is
known to be live rather than vacuous.

Admission requires the parent to be present, so ancestry never dangles
and the parent graph is acyclic by construction: a cycle would need one
of its members admitted before itself. A duplicate identity is refused
rather than overwritten, because overwriting is deletion renamed.

Organism identity and genome identity stay separate. A death is terminal
for the organism and touches nothing about the genome it carried;
ancestry, descendants and divergence all resolve afterwards.

The quieter risk is calling something extinct that is merely unobserved.
The archive reports living or absent and has no third answer: terminal
extinction is a policy judgement over a reconciled watermark covering
suspended members, eggs, spores and in-flight transfers, none of which
this type can see, so the word does not appear in the API. Absence is
also reversible, and a test shows a lineage regaining a carrier.

Capacity is bounded and admission fails loudly at the limit, since
refusing to record is not deleting but a silent drop would be.

The roadmap lists an NPC-mutation decision as a dependency, and
OPEN_QUESTIONS leaves it open until M12. It stays open: the archive
records an origin event and never an actor, so whether an NPC may
diverge changes nothing here.

Two clang-tidy findings were fixed rather than suppressed. std::map
members made the archive's move potentially throwing, because MSVC's map
move constructor allocates; sorted vectors replaced them. A wrapper
struct holding a Genome by value had the same problem, since ADR-0030
made Genome copy-only, so genomes are stored directly under their own
id(). The redundant carrier tally went with it: carriers are counted from
the organism records, so no second tally can drift.

Native Release, clang-tidy analysis, ASan and format checks pass 21/21.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-23 16:55:36 -04:00
dingoandClaude Opus 5 5497f4d74c Propose mutations without proposing a best build
M3.4 adds the candidate-generation experiment GENOME_MODEL describes: a
static catalog of four effects over the seven capabilities, drawn from a
recorded context with an explicit stream.

The named risk is a hidden best build or offerings biased toward what
would help, so the defence is structural rather than asserted. Nothing is
ranked: candidates are drawn without replacement by rejection sampling,
making every eligible operator exactly as likely as any other, and the
result is returned sorted by operator ID. No score exists in the record,
position carries no meaning, and nothing about an organism's situation
makes a helpful mutation more likely to be offered.

Eligibility is not a second rulebook. An operator is eligible when the
genome it would produce passes the M3.1 validation unchanged, so
prerequisites, required capabilities, ranges and the acyclic development
graph are enforced once, where they were defined. Shedding a capability
another declares as a prerequisite fails that check with no rule written
here to catch it. Range boundaries are refused rather than clamped, since
a clamp would make two operators agree and offer a no-op as a choice.

The draw reads the parent digest and the context and nothing else, so the
same context always returns the same candidates and a retry cannot
reroll; a new event index is what earns a new draw. select_mutation
regenerates the offer and refuses unless it still matches, so a changed
context is rejected rather than answered with a different mutation.

Cost is not invented: a candidate reports the successor's own maintenance
and mass under ADR-0032, and reserves nothing.

The eligible set is pinned by hand from the schema rather than observed,
and the uniformity check is confirmed to fail against a draw that takes
the first eligible operators. The rejection sampling that removes modulo
bias is correct by construction, not test-verified: at this scale the
bias is one part in 10^18. That is recorded rather than claimed.

No organism mutates and no fixture calls any of this. Candidate count,
mutation cost as a game rule, inherited versus acquired expression, NPC
mutation and recombination all remain open, as GENOME_MODEL requires.

Native Release, clang-tidy analysis, ASan and format checks pass 20/20.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-23 15:27:21 -04:00
dingoandClaude Opus 5 be71d4f441 Give capability a cost without giving it a multiplier
M3.3 turns a phenotype into the budgets a ledger can hold: body
composition, maintenance, movement, the next construction step, the
per-tick intake limit and the reproduction investment. metabolism is the
single place the genome's description of capability becomes accounting
quantities, so the record itself stays free of those types and M3.1's
boundary is crossed once, explicitly.

The named risk is reintroducing RPG modifiers, where a capability
parameter becomes a flat percentage over every budget. Each budget is
therefore derived from a different phenotype quantity: maintenance from
mass plus membrane upkeep, movement from mass and speed, intake from
surface, construction from the mass a growth step adds, investment from
the body a parent already has. One parameter moves some budgets and not
others, by different amounts. Doubling membrane thickness costs more
matter to build, more energy to hold and more to haul, while leaving
uptake, speed, assimilation and structural mass identical, and the mass
and maintenance ratios differ, so no single multiplier could produce it.
The test asserts that non-uniformity rather than describing it.

Composition is declared per compartment, and membrane is the carbon-rich
one, so a thicker membrane changes what a body is made of and not only
how much. A split assigns the first three channels by share and gives the
remainder to the last, so parts always sum back to the whole and a
derived body can be spent through the ledger without a rounding leak.
That is checked at four awkward masses where every share floors.

processes::consumer_for is the first path from a genome into the M2
fixtures. Opening inventory stays the caller's: a genome says what an
organism can do, never what it holds, and a derived config that invented
an opening balance would create matter. A derived consumer is shown
driving a real feeding tick with the ledger conserving exactly, and a
bite one femtogram past the derived cap refused by the M2.3 contract.

Every budget is asserted as a hand-calculated literal. The constants are
chosen so budgets are of comparable magnitude, which is legibility for
tests and not tuning. No existing fixture reads genomes, and no organism
spends any budget: there is still no starvation, death or repair rule.

Native Release, clang-tidy analysis, ASan and format checks pass 19/19;
every existing golden and fingerprint is unchanged. Linux CI has not run.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-23 11:31:01 -04:00
dingoandClaude Opus 5 3f86dada0e Derive a phenotype from the genome without touching it
M3.2 adds derive_phenotype and plan_development as pure integer
functions of a genome, a growth state and an environment. Nothing is
stored: a phenotype is recomputed from retained inputs rather than
cached, so a cached copy can always be checked against a recomputation.

The risk this increment was scoped against is confusing the genome with
runtime damage. Growth and damage live in a separate state that no
function may write back, and no entry point takes a mutable genome.
Damage changes the phenotype and leaves the encoded bytes and content
digest identical, so heredity cannot carry acquired condition.

The genome's development version selects a rule set, which is what makes
that field worth carrying; an unknown version fails closed rather than
deriving under the wrong rules. Version 1 declares every constant. The
shape model is explicit rather than implied: the body is a cube of
uniform declared density, so extent is an exact integer cube root and
surface is six extents squared. Membrane mass follows surface and the
genome's thickness, maintenance follows total mass plus a membrane
upkeep term, and uptake scales with surface, so size trades uptake
against maintenance. A capability the genome does not carry yields zero.

A plan advances growth by at most the rule step, reduced to the largest
step the available material funds exactly, never a partial one and never
a grant. It reserves nothing and pays for nothing: the matching transfer
does not exist until M3.3, and an apply that moved no inventory would
look like a committed operation while conserving nothing.

The fixture genome is an exact 20 micrometre cube, so every derived value
is asserted as a hand-calculated literal, as are the half-built, damaged,
maximum and cube-root-boundary cases. Determinism is checked over 45
growth and temperature combinations. The declared flooring is pinned
rather than hidden: a body whose mass floors to zero advances its counter
for no material, granting no structure because none exists either way.

Omitted physics is a documented model limitation, not a modifier. Nothing
here is balance, and no organism yet develops. Native Release, clang-tidy
analysis, ASan and format checks pass 18/18; every existing golden and
fingerprint is unchanged. Linux CI has not run yet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 21:48:24 -04:00
dingoandClaude Opus 5 8584eb1f6f Add the immutable genome v1 record and its canonical encoding
Open M3 with the record that development and mutation will read, in a new
evo::biology library that nothing else links yet. A genome is validated
once at construction and exposes no mutator, so an invalid one cannot
exist at runtime and callers never revalidate. A draft carries
unvalidated input; create and decode apply identical semantic checks, so
a decoded record is never less validated than a constructed one.

Schema 1 fixes the seven v0.1 capability kinds. Each has a unit, an
inclusive range, whether every genome must carry it, and the capabilities
it mandates, all held as schema facts rather than record data, so no
record can contradict its own units. A capability adds one parameter and
a bitmask of declared developmental edges; the union of declared and
mandated edges must be acyclic, which seven nodes make exact and bounded.

Identity is a nonzero world-scoped genome ID distinct from every runtime
identity, a nonzero origin event, and zero or one parent. Zero parents
identifies a documented founder. The format reserves room for a second so
recombination needs a schema version rather than a layout change.

The encoding follows ADR-0008: explicit little endian, bounded before any
allocation, an exact length match so trailing bytes are rejected, records
strictly ascending by kind so the bytes are canonical and duplicates fall
out of the same comparison, a stored digest recomputed on decode, and a
trailing checksum. The digest covers identity and ancestry, so identical
capabilities from different origins never share one. Neither value is an
authenticity claim. Unknown schema versions fail closed.

Tests cover ancestry rules, every declared range boundary from both
sides, self, mutual and three-node cycles, a cycle closed by a mandated
edge, truncation at every length, trailing and oversized buffers, every
single-byte corruption, and three resealed edits that reach the digest,
version and ordering checks rather than stopping at the checksum. One
branch is recorded as uncovered rather than given a test that cannot
fail: in schema 1 every mandated capability is also required.

No genome affects any simulation. Native Release, clang-tidy analysis,
ASan and format checks pass 17/17; golden d61ad5bf0c928c76 and ecosystem
fingerprint 2cd4a15f9fbe9949 are unchanged. Linux CI has not run yet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 20:53:23 -04:00
dingoandClaude Opus 5 eaf58f2b85 Drive the energy cycle with measured ecosystem episodes
Close M2 with a deterministic driver that owns one community and one
seeded stream, holds no inventory and emits only the terminal, feeding
and reproduction intents the earlier increments already accept. No
simulation contract changed to make the cycle run unattended.

Two limits shaped the design. Identities are never reused and slots are
capped, so one community supports a bounded number of consumer lifetimes
and is not a population. No maintenance cost exists, so a consumer that
is never eaten never dies, and inventing a starvation rule here would
settle a question ENERGY_MODEL leaves open inside a measurement harness.
The harness therefore measures many bounded episodes, taking mortality
from predation and from a configured lifespan delivered as an ADR-0027
host terminal fact. Lifespan bounds an episode; it is not senescence.

The driver must never submit a batch the community rejects, so it probes
a discarded copy each tick to size bites against the state feeding will
actually see, claims each target for one feeder, and excludes a bitten
consumer from acting. A rejected tick is reported as a driver defect
rather than absorbed as ecology.

Across 64 seeds the suite steps tick by tick, requiring exact conserved
totals at every tick and an identical report on replay, and covers both
mortality paths, slot exhaustion, tick-limit termination, lineage
attribution, episode independence and configuration rejection.
evo-sim --ecosystem reports seeded ensembles: 3,000 episodes advanced
1,093,007 ticks, all reaching extinction, with deaths reconciling exactly
against founders plus births. That demonstrates arithmetic and turnover,
not ecological plausibility; strategy constants are chosen inputs.

Native Release, clang-tidy analysis, ASan and format checks pass 11/11;
golden d61ad5bf0c928c76 is unchanged. Linux CI has not run yet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 17:38:34 -04:00
dingoandClaude Opus 5 c84a701edf Add funded reproduction with retained lineage identity
Close the M2.5 fixture cycle. A bounded list of trusted reproduction
intents runs after feeding and before decomposition, so a consumer can
fund offspring from what it ingested and a process terminated in that
tick cannot reproduce. The intent names a withdrawal from the parent
reservoir; a fixed construction fraction endows the child and the
remainder becomes real heat and waste. Nothing is credited from outside
the community, so conserved totals are unchanged by a birth.

Reserved slots are pre-allocated at creation, so a birth never grows the
ledger and a full community rejects rather than funding a smaller child.
Slots never return to the unborn state, so process identities are never
reused, and a parent reference plus origin tick outlive both organisms
and survive decomposition. A child duplicates the configuration of its
parent because no genome exists yet; this is duplication, not heredity.

Default zero capacity leaves the M2.4 reservoir layout and every existing
result unchanged, including golden d61ad5bf0c928c76. Native Release,
clang-tidy analysis, ASan and format checks pass; Linux CI has not run
for this increment yet. This defines no reproductive strategy, fecundity
rule, mutation model, gestation, spatial placement or account ownership.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-21 20:36:49 -04:00
dingo e17a9a7279 Preserve terminal inventories and add bounded decomposition 2026-09-20 15:26:58 -04:00
dingo b7dd466f57 Add shared feeding community with atomic resource transfers 2026-09-20 10:28:54 -04:00
dingo af293b8b50 Add finite producer capture and resource-limited growth process 2026-09-20 08:56:46 -04:00
dingo 8fd3591b0e Add atomic conserved energy and elemental inventory ledger 2026-09-19 19:42:29 -04:00
dingoandClaude Opus 5 d5b4bd068e Initial commit: architecture docs and headless engineering proof
Aeternalis Evolution, a custom-engine persistent evolutionary MMO.

This first commit establishes the project skeleton:

- Architecture and design docs: project vision, system overview,
  engineering constitution, roadmap, 19 ADRs, and the simulation,
  world, network, persistence and infrastructure architectures.
- Headless engineering proof: deterministic synthetic particles,
  component lifecycle, explicit PRNG streams, canonical snapshots
  and restored execution.
- Build and tooling: CMake 3.28+ / Ninja presets, C++23 feature
  check, clang-format and clang-tidy config, format check script,
  Windows check script, and a Docker build context.
- Tests: unit tests, benchmarks, a snapshot fuzz target and CLI
  integration wiring.

No gameplay, renderer, network service or running deployment yet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 15:44:41 -04:00