Repository navigation
fix(oracle-gaps): retire a batch's copies from Vitest's state - #61
Conversation
A check runs each mutant in a new copy of its test file. Vitest's state kept every file and test task it ever ran (filesMap by path, idMap by task id), so a check held every test of every copy: about 377k test cases on a four-file suite, which exhausted a 2 GB heap. Once a batch's units are plain data, its copies leave the state: their stale idMap entries go first (shape-guarded), then clearFiles replaces each path's file entry. Co-authored-by: Isaac <no-reply@databricks.com>
|
Important Draft PR not reviewedDraft PRs are not automatically reviewed by default.
To automatically review draft PRs, update your CodeRabbit configuration: reviews:
auto_review:
drafts: true
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. |
|
commit: |
The gap CLI's e2e driver sets ORACLE_GAPS_TEST_RETENTION on each run and records one line per batch: the count of Vitest state entries (filesMap, pathsSet, idMap) and Vite module nodes that still name the batch's retired copies. The law: each count is 0 after retirement. This commit adds the hook and the law, not the fix, so CI records the RED on the parent code. Co-authored-by: Isaac <no-reply@databricks.com>
… file entry Vitest's clearFiles replaces a copy's file entry, and leaves its path in pathsSet, one placeholder task in idMap, and Vite's module node and transform for the copy. The retention law (bounded retention, after each batch) fails on 46dfd3e in CI: each count is nonzero. retireCopies now removes the copy's filesMap key, pathsSet entry, and idMap tasks. retireModules invalidates each copy's module through Vite's API and removes it from every environment's graph maps. Both guard the shapes they touch and throw if one changes, so a Vitest or Vite that changes them fails loudly rather than leaking. Co-authored-by: Isaac <no-reply@databricks.com>
… log When the cold run exits 3, its stack is in its error.log. The incremental violation named only the exit code, so a failure printed no stack. It now appends the error log the driver already reads for a run that exits 3. Co-authored-by: Isaac <no-reply@databricks.com>
…rror log ce46f4b appends cold.stderr to the incremental violation when the cold run exits 3, but the incremental observation's cold run had no stderr, so the message stayed empty. It now carries the run's stderr, with its error.log, when it exits 3, and only then: a completed run's stderr holds timings, which differ between two runs of one history. Co-authored-by: Isaac <no-reply@databricks.com>
…s not retired A replaced context stayed reachable through indexOf and contextSpecs, which were never cleared for it, so its Vitest and Vite state stayed too. replace now drops both entries. A run cut off by a hang is not retired: its worker may still send updates, and its context is replaced by the caller. Also: the etag map is cleaned by node identity (Vite keys it by the etag), and the retention observation is the count of batches left with a retired copy's state, which is deterministic, not the per-batch lines. Co-authored-by: Isaac <no-reply@databricks.com>
…s size before the batch The hook now snapshots every structure a copy can leave state in (Vitest's filesMap, pathsSet, idMap, errorsSet, leakSet, and each Vite environment's url, id, etag and file maps and transformed nodes) before a batch, and the law requires each to return to its size after the batch's retirement. The law was tautological before: it counted the same predicate the deletion used. The retention observation is observed from every run kind (cold, daemon, stability, partial), and a run that computed a unit must have written a batch line. A check that ran more than one batch reaches a declared state. Co-authored-by: Isaac <no-reply@databricks.com>
…a batch line is owed by mutant results The totals now include the excess of indexOf and contextSpecs over the live contexts, which must be zero before each batch: a context replaced between batches is caught there, not by a single batch's before and after. The missing-line expectation read evidence.computed, which counts single-file runs that write no batch line, so it failed on ce6c93d. A run owes a batch line when a mutant has owner files, since such a mutant's units ran in batches. Without that check, a retirement that never runs writes no line and passes the count law vacuously: the no-retire ablation exited 0. Co-authored-by: Isaac <no-reply@databricks.com>
Co-authored-by: Isaac <no-reply@databricks.com>
The cold check's store kept every computed unit, with its rows, for the whole run: 207 store entries and 103,585 row entries in the ce6c93d heap snapshot. A cold run serves no lookup (evidence.reused is 0 on every klona run), so the store now keeps nothing. The daemon's disk store is unchanged. The retention totals include the store's size, which must match before and after each batch. Paired identity runs (pre-change and this commit, both cut 0) give the same 391 results, and the baseline matches both. Co-authored-by: Isaac <no-reply@databricks.com>
…hes are logged evidence.batches counts every batch run (cut or not). Each batch writes one retention line, so each run's line count must equal batches: a run with no line for a batch it ran (the no-retire mutant) fails the law. A cut batch writes its before line, so the stale totals of a replaced context are checked there. Co-authored-by: Isaac <no-reply@databricks.com>
…t every cached module Vite's graph caches non-copy modules (a source or harness file, on first import), which legitimately grow during a batch; the before-and-after equality was wrong for Vite keys. The law now requires the copies' own module nodes to be zero after each settled batch, and keeps the before-and-after equality for Vitest's state, the store, and the stale context totals. Co-authored-by: Isaac <no-reply@databricks.com>
…on-copy nodes to one per file Vite's totals are named vite.<environment>.<map>, so the law tells them from Vitest's state by an explicit prefix the hook generates. After each settled batch, the copies' own module nodes must be 0, and each non-copy file (query stripped) has at most one node in each environment's graph: a file cached once per batch under a fresh id fails the law. Co-authored-by: Isaac <no-reply@databricks.com>
…o the completion law; the multi-batch state is declared A run with no report owes no batch line here: the completion law judges it, keyed on the model's prediction (a report unless a refusal is predicted), and fails it with its exit status and stderr. The multi-batch reach state is declared in the property's measured list. Co-authored-by: Isaac <no-reply@databricks.com>
…ched Co-authored-by: Isaac <no-reply@databricks.com>
… per package, counted as a delta A daemon keeps the environment of the call that started it, so a later daemon check wrote its retention lines to the hook file of the call that started the daemon, and its own (new) hook file was empty: the exact batch-line count failed on a correct run (retentionLines:daemon on the hang history). Counting side: every call for a package writes to one file, and a run's lines are the ones after its start. The production batch-line contract is unchanged. Co-authored-by: Isaac <no-reply@databricks.com>
…tory; a run keeps its own lines Replaces the delta: a daemon serves many calls and keeps the first caller's environment, so a line is attributed to the check that wrote it (its out directory, the test hook's only addition), and the run keeps the lines that name its own out directory. Two daemon checks at once against one hook file cannot mix. No production outcome changes. Co-authored-by: Isaac <no-reply@databricks.com>
…able names each run's batches and lines Diagnostic for the daemon line mismatch (the test hook only; no production outcome changes). Co-authored-by: Isaac <no-reply@databricks.com>
… retention lines are its own The table showed the cause: a daemon serves several checks of one test, and two of them shared an out directory, so a run kept lines written by an earlier check (batches 1, lines 4; a run with 0 batches kept 1). Production wrote one line per batch in every run. The counting side is wrong: each call gets its own directory, so the run filter sees only its lines. The debug table is removed (it was for this diagnosis). No production change. Co-authored-by: Isaac <no-reply@databricks.com>
…tories runCli gives each call Each call's out directory is numbered (out-<n>, out-daemon-<n>, ...), so the outputs of a run are its own. The law's list of own outputs names the fixed ones; the numbered ones match the same pattern the driver creates (OWN_NUMBERED). Without it, a run's out-25 writes read as strays. Co-authored-by: Isaac <no-reply@databricks.com>
…as given Repair, not widening (P7): the law listed fixed output names (out, out-daemon, out-stop, out-only), and numbered names were a pattern. Now each run's allowed output is the one path the model predicts (its --out, from cliArgs): runCli passes its numbered out, the stop law passes out-stop. A CLI that writes under any other directory, such as out-<n>-next, is a stray. The lists are removed. Co-authored-by: Isaac <no-reply@databricks.com>
…r fingerprint lists The generator canary (gap-report-history-fingerprint) records each field's draws in draw order, and a new field is recorded at the end of both lists. rejectBatch (the constant 0, drawn last) is appended in drawn and histories; every earlier line is unchanged. Co-authored-by: Isaac <no-reply@databricks.com>
…amespace law The earlier exemption skipped the namespace law for the constructed rejected batch. Restored: the law judges every write of that run. Whatever an internal error leaves behind is then either removed by the CLI or predicted by the model, decided on the evidence of the run that follows. Co-authored-by: Isaac <no-reply@databricks.com>
# Conflicts: # packages/oracles/oracle-gaps/gap-report-model-oracle.mjs # packages/oracles/oracle-gaps/gap-report-oracle.property.test.mjs # packages/oracles/oracle-gaps/history-fingerprint.json # packages/oracles/scripts/pr-shards.mjs
…andom config cannot refuse it before its batch The random-seed run of the constructed history drew a CommonJS package with a .js config, which the CLI refuses before any batch, so no batch ran and no retention line was written (retentionLines:reject). The constructed history now pins its package type and config file (ordinary values, so its take-back stays in the language), and the fixed and determinism units were already unaffected. Co-authored-by: Isaac <no-reply@databricks.com>
…fig placement A random run drew a native addon and a config in the parent directory, which the CLI refused before its batch (retentionLines:reject again). The history pins both to the values of the daemon history, so no random scenario setting refuses it. Co-authored-by: Isaac <no-reply@databricks.com>
… wrote them A line named its run's output directory only, so a daemon the CLI killed mid-check (its batches ran and wrote lines to that directory) was counted against the run that reported, which ran no batch of its own (retentionLines:daemon on the dieMidCheck step, shard 3 of the merged head). The hook line now carries the writing process's pid (observation only). A run's retention is its child's lines; the lines a daemon it killed wrote are judged as that daemon's: each complete and retired (retention:killed). A killed process reports no batch count, so its count is not judged here; the batch it died in writes no line (a Limit). Co-authored-by: Isaac <no-reply@databricks.com>
…retention lines are attributed by it The CLI runs its check in a supervised child, so the pid of the process the driver spawned is not the process that writes the lines (the first attribution failed every cold run). Under ORACLE_GAPS_TEST_RETENTION the check writes its own pid into its output directory (observation only), and the driver attributes a run's lines to that pid. A daemon the CLI killed writes other pids, and its lines are judged as that daemon's (retention:killed). Co-authored-by: Isaac <no-reply@databricks.com>
…the framework's unbuild is reverted The constructed history "a batch whose run rejects" sets the constructed-only field rejectBatch. Main's mechanism for such fields (register: generator rule, extended) takes them back inside the model's histories mapping, as it does for pauseEngages and warmReplaced, so the framework's membership check (F20) is unchanged. This reverts the ConstructedHistory.unbuild addition (954a5f3, cb25107): #61 no longer changes packages/oracles/src. Co-authored-by: Isaac <no-reply@databricks.com>
… writer, and counts batches by their own index The retention hook moves into retention-hook.mjs, which the CLI loads only when a hook variable is set and which the package does not publish. Its fields observe the real objects (review of #61, F6): staleOpen reads Vitest's own close state of each context that left the live array, and the cold store's law counts the entries given to put that a full collection leaves reachable (held), in place of a size the store reported about itself. The openContexts set, the replacing count, the memoryStore size and evidence.batches, kept only for the hook, are deleted (F10), with the unread retireModules count and the globSpecs wrapper. Each line carries its batch's own index (F11). The law over one call's lines (retentionBreaches) judges every line for the call's --out: a line from a pid other than the check's is allowed only from a daemon the driver killed and saw die, so two processes running one call's check, or a line with no pid, is a breach (F4). A check that reached its report owns indices 0..n-1, each once; a check that ended early, a stopped run and a killed daemon own each index at most once. The warm and mid-run calls are judged too. The rejected-batch fault now rejects after the batch's run completes, so its copies are in Vitest's and Vite's state and their retirement is witnessed (F5). Its run's done line is judged on both streams, and the Limits state the actual check order. The README documents check.pid, pid, held and the new batch index (F3). Co-authored-by: Isaac <no-reply@databricks.com>
…nd check pid Co-authored-by: Isaac <no-reply@databricks.com>
… reach state Co-authored-by: Isaac <no-reply@databricks.com>
…pended Every stop of a history writes under out-stop, so an earlier stop's lines named the same run and a pid other than this stop's check (found by the shared-index mutant's run of "every outcome class"). Co-authored-by: Isaac <no-reply@databricks.com>
Co-authored-by: Isaac <no-reply@databricks.com>
main's constructed histories and its testRoot and loadPlugin fields come first; #61's rejected-batch history and its rejectBatch field follow them. Co-authored-by: Isaac <no-reply@databricks.com>
…es its package ships check.mjs imports retention-hook.mjs when a hook variable is set, and a shipped file may cite only what its package ships (eslint-plugin shipped-citations, maintainer finding F16). The CLI still loads the module only when a hook variable is set. Co-authored-by: Isaac <no-reply@databricks.com>
Main's constructed history from #61 ("a batch whose run rejects") comes first; this branch's history stays appended after it. The Limits take main's text with this branch's work-bound sentence. Co-authored-by: Isaac <no-reply@databricks.com>
#61's per-call output directories and retention hook meet #57's default output directory: a run without --out keeps no suffix, and its check pid and retention lines are read from the directory its note line names, before the run's scratch directory is removed. main's constructed history (a batch whose run rejects) and its rejectBatch field come first; #57's follow. Co-authored-by: Isaac <no-reply@databricks.com>
#61's constructed history ("a batch whose run rejects") comes before #99's, and its field rejectBatch before #99's hangMs; rejectBatch switches a test-only hook, so it stays a constant. Its env rides on the history's shared run options with #99's hooks. In runBatch, #61's try/finally (retire the batch's copies, write the retention line) wraps #99's cut handling: the spin rows, the built-in verdicts of cut copies, and the backstop's cause. The context replacement keeps #99's bounded close (closeWithin) with #61's registry swap. The fingerprint lists are recorded anew (M "Randomness wins"). Co-authored-by: Isaac <no-reply@databricks.com>
Summary
The gap CLI kept Vitest and Vite state for every mutant copy after its batch had finished. Each copy is a new file. Vitest kept its path in
filesMapandpathsSet, and its file and test tasks inidMap. Vite kept a module node and a transform for each copy. On the klona four-file suite (295 mutants, 2 contexts), the child ran out of a 2 GB heap before the check ended.This PR removes a batch's copies from Vitest's and Vite's state once the batch ends, however it ends. It keeps the context registry (
indexOf,contextSpecs) in step with the live contexts. A cold check's store keeps no unit.The retention law reads the hook's lines from
ORACLE_GAPS_TEST_RETENTION. After the merge-gate review, the hook moved intooracle-gaps/retention-hook.mjs. The CLI loads that module only when a hook variable is set. The module ships with the package, because a shipped file may cite only files its package ships (eslint-pluginshipped-citations, maintainer finding F16). Each field now observes the real objects:The law judges every line written for a call's
--out, whichever process wrote it. It counts batches by each batch's own index.#61 no longer changes
packages/oracles/src:git diff origin/main...HEAD -- packages/oracles/srcis empty.Law and authority
Bounded retention (e2e oracle, checkpoint
retention,retentionBreaches). After each settled or rejected batch:copyNodes);?rawpair (nonCopyDup);filesMap,pathsSet,idMap,errorsSetandleakSethave their sizes from before the batch.Before each batch:
indexOfentry names a live context at its own slot, and everycontextSpecskey names a live context;closingPromise(staleIndexed,staleSpecs,staleOpen).Authority: register C "fix(oracle-gaps): retire a batch's copies from Vitest's state #61 retention decisions" (retained Vitest and Vite state is removed after a batch).
Cold store (register C "fix(oracle-gaps): retire a batch's copies from Vitest's state #61 retention decisions" (1)): a cold check gives its store entries, and a full collection leaves none of them reachable (
held). A daemon's store keeps its entries by design, soheldis judged on cold calls only.One line per batch (register C "Runner laws" L2: exactly one line per batch, however the batch ends).
Line ownership (coordinator ruling of 2026-11-15 on fix(oracle-gaps): retire a batch's copies from Vitest's state #61: lines are counted per writing pid):
pidequals thecheck.pidthat the call's check wrote.daemonChecks) and that is dead when the line is judged.foreignLine): two processes ran one call's check.Non-copy bound (register C "fix(oracle-gaps): retire a batch's copies from Vitest's state #61 retention decisions" (2) and (3)): this is unchanged.
Rejected batch, check order (register C "E2E completion first" and P10):
The stream law is not applied to this run.
Decisions
heldreplaces the store's ownsize, which read 0 for main's store.staleOpenreads Vitest's own state, not a set kept for the hook.rejectBatchis taken back inside the model'shistoriesmapping, as main does forpauseEngagesandwarmReplaced(register: "Generator rule, extended"). TheConstructedHistory.unbuildaddition (954a5f3, cb25107) is reverted.ORACLE_GAPS_TEST_RETENTIONandORACLE_GAPS_TEST_REJECT_BATCHare inert unless set, and the README's test section documents them, includingcheck.pid,pid,batch,heldand the full collection.gc()(exposed throughv8.setFlagsFromStringandvm) after asetImmediateturn before it writes each line.a batch whose run rejectsis appended as the last one.rejectBatchisfc.constant(0)in the drawn record, last in the draw order, and recorded inhistory-fingerprint.json.evidence.batchesis deleted, soresults.jsonis unchanged from main. The unreadremovedcount, theglobSpecswrapper, theopenContextsset, thereplacingcount andmemoryStore().sizeare also deleted.Evidence
Head:
1f67a4b. It merges main at9aed105(#115, #103): #103's five new constructed histories come first, after main's earlier ones, anda batch whose run rejectsis the last.rejectBatchfollowstestRootandloadPluginin the drawn record and in the fingerprint. Runs on the Arclet pool are taggedr61-g-*-1f6(andr61-f-*-7d0at the previous head), with logs in/tmp/arca-results/. Local runs used/tmp/e2e-lock.sh, with logs in/tmp/fix61-logs/. Each mutant is a scratch branchscratch/fix61-<name>-g(local, not pushed). Each one is the same mutant commit, cherry-picked onto every head that was tested.Law: as stated above.
Reach: these are the fixed-seed shards at
7d0eccb(r61-f-g1/g2/g3-7d0; shard 3 at1f67a4bpasses 50 tests with the same states), summed over shards:incrementalStates)RED and mutants: each row runs the new oracle against a hostile change. Where the old oracle (head
099bf0a) was blind, the "Old oracle" column says so.retireCopieson rejection (if (raced && !cut))retention (copyNodes, filesMap, idMap, pathsSet)retention (rejectLine)memoryStore(rows Map, nosize)retention (held),retention:partial (held)closeContextnever closes (Promise.resolve)staleOpenatretention,retention:daemonandretention:coldpidforeignLinecheckColdinto the same--out, and then reports the daemon's summary)retention:daemon (foreignLine)retention (batchIndex),retention:daemon (batchIndex)retireCopiesnever runs)copyNodes, filesMap, idMap, pathsSetstaleOpenindexOfkept on replacestaleIndexedrejectBatch: 0removed from the take-back (scratch 67d8091)The histories for these runs:
fixed seed 20261105: a batch whose run rejects;a package with no config,a load failure beside a hangandtwo authored mutants;an edit that changed the cold result after a hang replaced the only context;a lazy module loaded before a hang in the same batch;an edit sequence through the daemon;two authored mutantsandan edit sequence through the daemon.Command:
pnpm exec vitest --run --config oracle-gaps/vitest.config.mjs gap-report-oracle -t "<history>$".GREEN at 1f67a4b:
random seedanddeterminismof the rejected batch pass, andrandom seed: an edit sequence through the daemonpasses.determinism: constructed history: an edit sequence through the daemonfailed: see "Determinism of the daemon history" below.Command:
pnpm exec vitest --run --config oracle-gaps/vitest.config.mjs gap-report-oracle -t "$(node scripts/pr-shards.mjs pattern oracle-gaps-fixed-seed N)".The finding the mutants found in the driver: the shared-index mutant's run of "every outcome class" also reported
retention:stop (foreignLine)on a GREEN code path. Every stop of a history writes underout-stop, so the lines of an earlier stop were read as this stop's. The driver now takes only the lines that a stopped run appended (ff5c021).Klona memory
This is unchanged since 65880b6, and it was not re-measured. The retirement and store code is the same, and the hook changes do not run without the variable. Command:
NODE_OPTIONS=--max-old-space-size=<MB> /usr/bin/time -l node <CLI>/index.mjs --package /tmp/oom/klona --source src/index.js,src/lite.js,src/full.js,src/json.js --seed 20261112 --contexts 2 --mutants /tmp/oom/mutants --out <dir>. Logs are in/tmp/r61-klona/.Weight
Method: each file is minified with esbuild 0.28.2 and then compressed with
gzip -9, fromgit archive. "Published" means theoracle-gapsfiles thatpackage.jsonfilesships.oracle-gaps, minified / gzipcheck.mjs, minified / gzipretention-hook.mjs(loaded only under a hook variable)check.mjswould remove the module overhead, but the hook code would then sit in the normal run path, against the F10 ruling.retireCopies,retireModules,viteEnvironmentsand their shape guards, the registry swap, and the race in the try.CI
Run 43811995544 at 1f67a4b. Every blocking job passed, and every one finished under 10 minutes. The longest were:
The run at 7d0eccb (43805253378) failed
Test eslint-plugin-oraclesandWindows unit suitesonshipped-citations. At that headcheck.mjscitedretention-hook.mjs, which the package did not ship. 1f67a4b fixes this by shipping the file.Windows (non-blocking, #73)
From run 43811995544 at 1f67a4b:
done completed, not the SIGABRT ending. This is the same as main (fix(oracle-gaps): supervise the check on win32; log each CLI run in the e2e driver #79).every outcome classon key stability:w_fastturn:if-falsewas killed in the first run and not-observed in the stability rerun. The time includes shrinking the failing history.At 099bf0a (run 43729584796), 3/10 failed with "161 gap lines for 160 gaps". I compared the 161 streamed lines with the model's 160 gaps for the failing history (replayed with
ORACLE_PATH=0:0). The extra line isgap not-observed L113 sut.ts:M95x > 2→false ``. That is the samew_fastturn:if-falsemutant. The model predicts it killed, by the work law in a test that waits a turn.The same comparison on #87's failing job (#73 at 104376d, before any #61 code) finds the same extra mutant (
L121 sut.ts:M112). The classification comes from the copy's capture rows, its work count and their time-dependency marks, and #61 does not change how those rows are read. Retirement runs after the units are plain data, and it removes only the copies' own nodes and entries. By that inspection, both 2/10 and 3/10 are #87's mutant, which is nondeterministic on win32, and not #61's.Determinism of the daemon history
determinism: constructed history: an edit sequence through the daemondiffers at thestartstep. In one run of the two, the second of the two checks started at once has thenote test outputline, and in the other run it does not. Main has the same difference (register "Main's determinism failures", #82). It failed 1 of 5 times at 9aed105 (r61-det-main-1…5; main's observation 1). On #61 heads it failed:A lookup diagnostic (scratch a901573, r61-diagdet-1…3, where 1 of 3 failed) shows the cause. Whichever of the two concurrent calls the daemon serves first computes every unit, and the other reuses all of them. So the observation depends on which CLI process reaches the daemon first, which is a wall-clock race between processes in the driver (register "Determinism under load covers witnesses"). The rate on #61 heads is higher in these small samples. I did not find a #61 change that decides the order.
Limits
One line per batch: the count rests on the index the hook takes when a batch starts. Two failures keep the indices at 0..n-1 and are not seen:
For checks that ended early and for killed daemons, the law checks each index at most once. It does not check that each finished batch has a line.
Ownership: a line's process is identified by
check.pid, which the check writes. The driver knows independently only the daemon it killed. The warm call and the mid-run calls are judged, and the killed daemon's lines are judged as that daemon's own.Cold store:
heldcounts the entries given toput, so a store that kept only a part of an entry (its unit without the entry) is not seen.staleOpen: it readsclosingPromise, which is set when a close starts. A close that starts and never resolves belongs to the runner oracle (L8). A context replaced after a check's last batch is seen only by a later check's first batch through the daemon.Rejected batch: the fault rejects after the batch's run completes. A crash in the middle of a run, with only some copies registered, is not generated. Retirement removes by path, so the same code covers any subset.
Load observation (not reproduced): one local fixed-seed shard 1 run at ff5c021, under load average about 10, failed
an edit sequence over the witness modulewith "incremental equals cold". The daemon's start check reporteddevBuild:return-undefinedas blocked bytests/a.test.ts, where the cold run had it survive. Reruns at ff5c021 and at 099bf0a passed. The failing check is the daemon's first, which runs its baseline before any batch, so no retention hook line ran in it. Its replay line is in/tmp/fix61-logs/g1-ff5.log. This is for the maintainer to file under the determinism-under-load rule.Determinism of the daemon history: see the section above. It is main's determinism: the hang-replaced-context history records different traces across two runs on main (observation 18, reach) #82 class, and its rate on this branch is higher in small samples.
These still apply from before: the non-copy bound (open), atomicity of the registry swap by construction, the driver holds (fix(oracle-gaps): Windows static and e2e failures, by class (follow-up to #58) #73), heartbeat state (reach: "a heartbeat named a busy mutant" depends on wall-clock timing and is reached 1 to 2 times per shard #84), heap growth (gap CLI heap still grows during a klona run after #61 (87 to 821 MB after GC; unattributed) #80), the determinism message (determinism violation prints only a 2,000-character prefix, hiding the first difference #81) and main's determinism failures (determinism: the hang-replaced-context history records different traces across two runs on main (observation 18, reach) #82).
This pull request and its description were written by Isaac.