From 060a83c05507b7c5ea99383205b6fc9f74a9f37d Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Mon, 31 Aug 2026 14:38:15 -0600 Subject: [PATCH 01/12] formal: sync scheduling verification track (P models + Occult) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two P model-checking projects and an Occult deductive track for the sync scheduler's crash/resume semantics, plus the specs, calibration logs, adversarial reviews, and synthesis report behind them. Purely additive: no production code, and the Occult host is a standalone Go module (root builds, tests, and lint do not touch it; it requires a sibling ../occult checkout to run). - formal/walker: the shipped design's model. 55 calibrated cells, 0 mismatches — every known bug class reds on its calibrated alarm (phantom union, session laundering and checkpoint consistency, hit rebind, warm drift, overlay placement, session elision, external principals) and every shipped/staged mitigation greens. - formal/graph: the demand-graph replacement runtime (frozen spec v4 after three adversarial rounds), 66-cell matrix plus the 12-cell bake-off that selected variant S (docs/rfcs/0011 is the kickoff). - formal/occult: 15 equational laws proved, the phantom union derived deductively, the syncer-connector protocol projected (MPST), and seven trace policies with a 140-cell verdict matrix; committed real-execution fixtures are judged by the same oracle. - formal/REPORT.md is the synthesis: findings register (two shipped defects among them), linkage grades, and standing limits. The trace-bridge fixture GENERATORS (the pkg/sync commit-order recorder and chaos exporters) land with the phase-6b PR; until then the committed JSONL fixtures are inert test data for the standalone oracle module. Co-authored-by: Cursor --- docs/rfcs/0011-demand-graph-sync-runtime.md | 159 ++ formal/.gitignore | 9 + formal/GLOSSARY.md | 209 +++ formal/GRAPH_MODEL_SPEC.md | 878 +++++++++ formal/MODEL_SPEC.md | 1580 +++++++++++++++++ formal/README.md | 83 + formal/REPORT.md | 282 +++ formal/graph/BAKEOFF.md | 151 ++ formal/graph/CALIBRATION.md | 400 +++++ .../graph/PCheckerOutput/bakeoff/summary.txt | 12 + formal/graph/PCheckerOutput/sweep/summary.txt | 67 + formal/graph/PSpec/Monitors.p | 764 ++++++++ formal/graph/PSrc/Env.p | 239 +++ formal/graph/PSrc/Events.p | 165 ++ formal/graph/PSrc/NodeExec.p | 418 +++++ formal/graph/PSrc/Sched.p | 818 +++++++++ formal/graph/PSrc/Store.p | 447 +++++ formal/graph/PSrc/Types.p | 241 +++ formal/graph/PSrc/Upstream.p | 111 ++ formal/graph/PTst/ScenarioG1.p | 167 ++ formal/graph/PTst/ScenarioG2.p | 324 ++++ formal/graph/PTst/ScenarioG3.p | 54 + formal/graph/PTst/ScenarioG5.p | 183 ++ formal/graph/PTst/ScenarioG5d.p | 137 ++ formal/graph/PTst/ScenarioG6.p | 274 +++ formal/graph/PTst/ScenarioG7.p | 50 + formal/graph/PTst/ScenarioG8.p | 128 ++ formal/graph/PTst/ScenarioG9.p | 114 ++ formal/graph/graph.pproj | 9 + formal/graph/tools/sweep.sh | 120 ++ formal/occult/LAWS.md | 86 + formal/occult/README.md | 185 ++ formal/occult/TRACE_BRIDGE.md | 278 +++ formal/occult/host/compression_test.go | 120 ++ .../host/constrained_params_probe_test.go | 212 +++ formal/occult/host/go.mod | 13 + formal/occult/host/go.sum | 6 + formal/occult/host/laws_test.go | 125 ++ formal/occult/host/phantom_test.go | 72 + formal/occult/host/pipeline_test.go | 136 ++ formal/occult/host/protocol_test.go | 89 + formal/occult/host/raft_probe_test.go | 16 + formal/occult/host/real_trace_oracle_test.go | 396 +++++ formal/occult/host/refimpl/refimpl.go | 219 +++ formal/occult/host/refimpl_oracle_test.go | 123 ++ .../realtraces/cold_record_sync.jsonl | 8 + .../external_resume_current_answer.jsonl | 36 + .../external_resume_sqlite_degrade.jsonl | 20 + .../realtraces/warm_replay_sync.jsonl | 9 + .../warm_replay_sync_interrupted.jsonl | 26 + .../warm_replay_sync_record_flip.jsonl | 25 + .../warm_replay_sync_session_zombie.jsonl | 11 + .../warm_replay_sync_tombstone.jsonl | 11 + formal/occult/host/trace_policies_test.go | 143 ++ formal/occult/src/sync_fixtures.occult | 9 + formal/occult/src/sync_laws.occult | 87 + formal/occult/src/sync_phantom.occult | 75 + formal/occult/src/sync_protocol.occult | 75 + formal/occult/src/sync_trace_policies.occult | 501 ++++++ formal/occult/tests/probe_axiom_fire.occult | 20 + ...e_axiom_fire.occult.occult.checkpoint.json | 7 + formal/reviews/graph-spec-round1.md | 943 ++++++++++ formal/reviews/graph-spec-round2-adoption.md | 743 ++++++++ formal/reviews/graph-spec-round3-repairs.md | 657 +++++++ formal/reviews/model-spec-round1.md | 34 + formal/reviews/model-spec-round2.md | 46 + formal/reviews/model-spec-round3.md | 47 + formal/reviews/model-spec-round4.md | 56 + formal/reviews/model-spec-round5-addenda.md | 84 + formal/reviews/model-spec-round6-scenario7.md | 91 + .../model-spec-round7-overlay-parallel.md | 332 ++++ formal/reviews/model-spec-round7-overlay.md | 353 ++++ formal/walker/CALIBRATION.md | 474 +++++ .../walker/PCheckerOutput/sweep/summary.txt | 56 + formal/walker/PSpec/Monitors.p | 630 +++++++ formal/walker/PSrc/Env.p | 347 ++++ formal/walker/PSrc/Events.p | 214 +++ formal/walker/PSrc/Scheduler.p | 496 ++++++ formal/walker/PSrc/Store.p | 466 +++++ formal/walker/PSrc/Types.p | 218 +++ formal/walker/PSrc/Upstream.p | 91 + formal/walker/PSrc/Worker.p | 782 ++++++++ formal/walker/PTst/Scenario1.p | 122 ++ formal/walker/PTst/Scenario2.p | 149 ++ formal/walker/PTst/Scenario3.p | 115 ++ formal/walker/PTst/Scenario4.p | 83 + formal/walker/PTst/Scenario5.p | 131 ++ formal/walker/PTst/Scenario6.p | 201 +++ formal/walker/PTst/Scenario7.p | 144 ++ formal/walker/PTst/Scenario8.p | 118 ++ formal/walker/PTst/ScenarioP4.p | 106 ++ formal/walker/tools/sweep.sh | 92 + .../traces/freeze-sweep-v11-summary.txt | 47 + .../walker/traces/msco001-sweep-summary.txt | 48 + formal/walker/walker.pproj | 9 + 95 files changed, 20257 insertions(+) create mode 100644 docs/rfcs/0011-demand-graph-sync-runtime.md create mode 100644 formal/.gitignore create mode 100644 formal/GLOSSARY.md create mode 100644 formal/GRAPH_MODEL_SPEC.md create mode 100644 formal/MODEL_SPEC.md create mode 100644 formal/README.md create mode 100644 formal/REPORT.md create mode 100644 formal/graph/BAKEOFF.md create mode 100644 formal/graph/CALIBRATION.md create mode 100644 formal/graph/PCheckerOutput/bakeoff/summary.txt create mode 100644 formal/graph/PCheckerOutput/sweep/summary.txt create mode 100644 formal/graph/PSpec/Monitors.p create mode 100644 formal/graph/PSrc/Env.p create mode 100644 formal/graph/PSrc/Events.p create mode 100644 formal/graph/PSrc/NodeExec.p create mode 100644 formal/graph/PSrc/Sched.p create mode 100644 formal/graph/PSrc/Store.p create mode 100644 formal/graph/PSrc/Types.p create mode 100644 formal/graph/PSrc/Upstream.p create mode 100644 formal/graph/PTst/ScenarioG1.p create mode 100644 formal/graph/PTst/ScenarioG2.p create mode 100644 formal/graph/PTst/ScenarioG3.p create mode 100644 formal/graph/PTst/ScenarioG5.p create mode 100644 formal/graph/PTst/ScenarioG5d.p create mode 100644 formal/graph/PTst/ScenarioG6.p create mode 100644 formal/graph/PTst/ScenarioG7.p create mode 100644 formal/graph/PTst/ScenarioG8.p create mode 100644 formal/graph/PTst/ScenarioG9.p create mode 100644 formal/graph/graph.pproj create mode 100755 formal/graph/tools/sweep.sh create mode 100644 formal/occult/LAWS.md create mode 100644 formal/occult/README.md create mode 100644 formal/occult/TRACE_BRIDGE.md create mode 100644 formal/occult/host/compression_test.go create mode 100644 formal/occult/host/constrained_params_probe_test.go create mode 100644 formal/occult/host/go.mod create mode 100644 formal/occult/host/go.sum create mode 100644 formal/occult/host/laws_test.go create mode 100644 formal/occult/host/phantom_test.go create mode 100644 formal/occult/host/pipeline_test.go create mode 100644 formal/occult/host/protocol_test.go create mode 100644 formal/occult/host/raft_probe_test.go create mode 100644 formal/occult/host/real_trace_oracle_test.go create mode 100644 formal/occult/host/refimpl/refimpl.go create mode 100644 formal/occult/host/refimpl_oracle_test.go create mode 100644 formal/occult/host/testdata/realtraces/cold_record_sync.jsonl create mode 100644 formal/occult/host/testdata/realtraces/external_resume_current_answer.jsonl create mode 100644 formal/occult/host/testdata/realtraces/external_resume_sqlite_degrade.jsonl create mode 100644 formal/occult/host/testdata/realtraces/warm_replay_sync.jsonl create mode 100644 formal/occult/host/testdata/realtraces/warm_replay_sync_interrupted.jsonl create mode 100644 formal/occult/host/testdata/realtraces/warm_replay_sync_record_flip.jsonl create mode 100644 formal/occult/host/testdata/realtraces/warm_replay_sync_session_zombie.jsonl create mode 100644 formal/occult/host/testdata/realtraces/warm_replay_sync_tombstone.jsonl create mode 100644 formal/occult/host/trace_policies_test.go create mode 100644 formal/occult/src/sync_fixtures.occult create mode 100644 formal/occult/src/sync_laws.occult create mode 100644 formal/occult/src/sync_phantom.occult create mode 100644 formal/occult/src/sync_protocol.occult create mode 100644 formal/occult/src/sync_trace_policies.occult create mode 100644 formal/occult/tests/probe_axiom_fire.occult create mode 100644 formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json create mode 100644 formal/reviews/graph-spec-round1.md create mode 100644 formal/reviews/graph-spec-round2-adoption.md create mode 100644 formal/reviews/graph-spec-round3-repairs.md create mode 100644 formal/reviews/model-spec-round1.md create mode 100644 formal/reviews/model-spec-round2.md create mode 100644 formal/reviews/model-spec-round3.md create mode 100644 formal/reviews/model-spec-round4.md create mode 100644 formal/reviews/model-spec-round5-addenda.md create mode 100644 formal/reviews/model-spec-round6-scenario7.md create mode 100644 formal/reviews/model-spec-round7-overlay-parallel.md create mode 100644 formal/reviews/model-spec-round7-overlay.md create mode 100644 formal/walker/CALIBRATION.md create mode 100644 formal/walker/PCheckerOutput/sweep/summary.txt create mode 100644 formal/walker/PSpec/Monitors.p create mode 100644 formal/walker/PSrc/Env.p create mode 100644 formal/walker/PSrc/Events.p create mode 100644 formal/walker/PSrc/Scheduler.p create mode 100644 formal/walker/PSrc/Store.p create mode 100644 formal/walker/PSrc/Types.p create mode 100644 formal/walker/PSrc/Upstream.p create mode 100644 formal/walker/PSrc/Worker.p create mode 100644 formal/walker/PTst/Scenario1.p create mode 100644 formal/walker/PTst/Scenario2.p create mode 100644 formal/walker/PTst/Scenario3.p create mode 100644 formal/walker/PTst/Scenario4.p create mode 100644 formal/walker/PTst/Scenario5.p create mode 100644 formal/walker/PTst/Scenario6.p create mode 100644 formal/walker/PTst/Scenario7.p create mode 100644 formal/walker/PTst/Scenario8.p create mode 100644 formal/walker/PTst/ScenarioP4.p create mode 100755 formal/walker/tools/sweep.sh create mode 100644 formal/walker/traces/freeze-sweep-v11-summary.txt create mode 100644 formal/walker/traces/msco001-sweep-summary.txt create mode 100644 formal/walker/walker.pproj diff --git a/docs/rfcs/0011-demand-graph-sync-runtime.md b/docs/rfcs/0011-demand-graph-sync-runtime.md new file mode 100644 index 000000000..39e6fc950 --- /dev/null +++ b/docs/rfcs/0011-demand-graph-sync-runtime.md @@ -0,0 +1,159 @@ +# RFC 0011: Demand-graph sync runtime — variant S over the shared chassis + +Status: kickoff draft — design mapping and verification plan for review; +no code yet. +Risk routing (REVIEW_CHECKLIST §2): scheduler + checkpoint + storage +semantics — silent/combinatorial subsystem, HIGH; the full BUG_CATCHING +step-up applies to every implementation phase. This RFC implements the +verdict of the formal effort (`formal/REPORT.md`); the design itself was +adversarially reviewed and model-checked before this document existed +(`formal/GRAPH_MODEL_SPEC.md` v4 frozen, `formal/graph/BAKEOFF.md`). + +## 1. Motivation + +The current tiered walker composes per-scope artifacts (fresh rounds, +source-cache replays, overlays) by position in an action queue. +The formal calibration model reproduces the known failure classes of +that design mechanically: the phantom union (individually truthful +responses composing into a false sealed artifact), session laundering +(a reader embedding a dead writer's value), and the artifact-swap +rebind hole (`formal/walker/CALIBRATION.md`, scenarios 1–3). Phase 6b's +mitigations close the calibrated instances; the classes remain +structural, because nothing in the runtime ties an artifact to the +premises it was derived from. + +The demand-graph runtime replaces positional composition with tracked +derivation: work is admitted by demand edges, every output carries its +lineage, and seal-time obligations are checked against a closure +oracle rather than assumed from queue completion. Two lineage variants +were modeled and baked off; the registered decision rule selected +**variant S — observable-causal stamps** (`formal/graph/BAKEOFF.md`). +This RFC maps that verdict onto `pkg/sync`. + +## 2. What is being built (the frozen mechanism inventory) + +From the spec's frozen tally (`formal/GRAPH_MODEL_SPEC.md` §7.5): + +**Shared chassis** — frontier checkpoint carrying the +admitted-derivation set (death semantics, admitted-by edges, cursors); +forced resume checkpoint; generation table with the bump rule, +quiesce-before-bump, and the total mint fence; premise-validated +markers (premise digests, publishBearing, adopt-or-re-derive under +MATCH-only and writer-ineligibility); the supersession matrix and +poison rule; the seal-time sweep with the closure oracle; atomic +units. + +**Variant S adds** — a per-output stamp field with the `eAdopt` +rewrite; stamp merge on read; three observation points (dispatch-time +refusal, session-read read-through with the dead-read count, the +pre-seal pass with an iteration budget); optional bucketed +compression, admissible only under the G9-CAL-1 minting rules. + +Not built: everything on E's bill (durable edge checkpoint rows, the +∀-pending-purge, support rebuild + agreement check, the retraction +queue), and the constrained session primitives as a correctness +requirement — under S they demote to a stamp-width optimization +(BAKEOFF design consequence 1). + +## 3. Model-to-Go mapping (proposed referents) + +The model speaks of nodes, output keys, and generations. The proposed +concrete referents, chosen to coincide with the partition granularity +phase 6b already established: + +| model concept | proposed Go referent | +|---|---| +| node | a scoped derivation task: one (action kind, rowKind, scopeKey) instance — the unit the tiered walker already dispatches | +| output key | the (rowKind, scopeKey) partition — the granularity of `sourcecache` replay, validators, and the trace oracle | +| generation | new durable table in the c1z store: (node, gen) rows with the mint fence; minting rides the existing checkpoint commit | +| frontier checkpoint | extends the existing checkpoint token (`pkg/sync` state marshalling): admitted-derivation set + admitted-by edges + cursors replace positional queue state | +| premise-validated marker | generalizes the source-cache manifest entry (`PutSourceCacheEntry` validators are proto-markers today); adds the premise digest and publishBearing bit | +| atomic unit | generalizes the 6b replay unit (clear + copy + marker + publish as one store transaction) to all derivation commits | +| per-output stamp | new column on partition rows or a per-partition sidecar (open question 2); merged on read, rewritten by adopt | +| dispatch-time refusal | frontier scheduler gate, replacing queue-order dispatch | +| session-read read-through | the session store consults the generation table on read; dead reads counted, not blocked | +| pre-seal pass | `EndSync` extension: bounded staleness chase over the demand closure before seal | +| closure oracle | seal-time check that every demanded output is present and stamped live — the sweep's authority | + +## 4. Strategy: sibling runtime behind a capability, not in-place surgery + +The tiered walker with 6b mitigations is shipping and calibrated. The +proposal is a parallel scheduler path selected per-sync (capability or +config flag), reusing the store, the connector protocol, and the +source-cache annotation surface unchanged — the demand graph changes +WHO dispatches work and WHAT lineage it records, not the wire contract +or row storage. Rationale: the runtime's correctness argument is +holistic (chassis mechanisms interlock; the spec's kill cells show +single-mechanism removals are silently unsafe), so incremental +in-place evolution would transit through states the model says are +broken. Rollout gates on dual-run conformance (§6). + +## 5. Design consequences carried from the bake-off + +Verbatim obligations from `formal/graph/BAKEOFF.md`: + +1. Constrained session primitives are an optimization (stamp width), + not a correctness gate; free-form session reads are safe under S. +2. Upstream validators and node generations get the same + observation-point discipline — consult at observation time. +3. Compression, if shipped, ships only with the G9-CAL-1 minting + rules (as first drafted it livelocked honest histories). +4. The dying-reader race kill needed feedback-PCT and a third worker + to exhibit: implementation tests for that race MUST use perturbed + or priority-based schedules, not uniform random chaos. + +## 6. Verification plan (the bridge stays load-bearing) + +- **Trace oracle first.** Extend the canonical vocabulary + (`formal/occult/src/sync_trace_policies.occult`, + `formal/occult/TRACE_BRIDGE.md`) with generation stamps and + admission events BEFORE the runtime lands; the recorder pattern + (`pkg/sync/sync_trace_audit.go`, nil in production) extends as-is. + Every implementation phase exports fixtures; the oracle judges + them. Note the engine's current trace-length ceiling (ask 8 of the + Occult engine brief) bounds fixture size until fixed. +- **Refimpl as executable spec.** The demand-graph reference + implementation (`formal/occult/host/refimpl/`) already produces + oracle-green traces; production traces must be conformant to the + same policies, and divergences route to whichever side is wrong. +- **Chaos parity.** The 6b chaos scenarios re-run under the new + runtime; crash schedules must include the perturbed-schedule + requirement from §5.4. +- **Dual-run conformance gate.** Same connector dataset, both + runtimes, sealed artifacts compared row-for-row (the `diff` + machinery exists). Ships only behind N green dual-runs on the + chaos corpus plus real connector fixtures. +- **Review routing.** Every phase is HIGH; BUG_CATCHING's step-up is + the floor, and the model's kill cells double as the adversarial + test inventory (each calibrated mutant names a regression test the + implementation must carry). + +## 7. Open questions (to resolve in review before phase 1) + +1. **Node identity vs dynamic fan-out.** The model's nodes are + static; real syncs spawn scoped actions dynamically + (`EnqueuePageTokens`, RFC 0007). Does a spawned child admit under + its parent's demand edge, and is the admitted-derivation set's + death semantics compatible with cursor-spawned siblings? +2. **Stamp storage.** Per-row column, per-partition sidecar, or + in-manifest? Width is unmodeled (BAKEOFF honest limits); measure + before choosing. Compression is the pressure valve, not the plan. +3. **Pass budget at scale.** The 3-iteration pre-seal budget is a + small-scope declaration. Production policy on budget exhaustion + (fail the sync loud vs degrade) needs an explicit decision — + the model says exhaustion with dead stamps is a mechanism bug, + which argues for loud failure. +4. **Generation-table growth.** Mint-per-bump with sync-scoped + lifetime suggests table truncation at seal; confirm no + cross-sync reader (warm consults read markers, not generations). +5. **Coexistence window.** How long do both runtimes ship? The 6b + mitigations stay calibrated in the walker model for as long as + the walker ships. + +## 8. What this RFC is not + +Not a phase plan with estimates (that follows once §7 resolves), not +a storage-schema spec (open question 2 gates it), and not a promise +that the model's guarantees transfer to code — the model arbitrates +the design; the trace oracle and dual-run gates are what tie the +implementation to it (`formal/REPORT.md`, "What is guaranteed"). diff --git a/formal/.gitignore b/formal/.gitignore new file mode 100644 index 000000000..6bcb02656 --- /dev/null +++ b/formal/.gitignore @@ -0,0 +1,9 @@ +# Regenerable P toolchain outputs (p compile / p check). The sweep +# summaries the calibration logs cite as evidence are force-added. +PGenerated/ +PCheckerOutput/ +# Machine-replay counterexample archives (~200k lines across the +# calibrated reds). Regenerate any cell's replay with +# `p check -tc ` per the run log; the committed evidence is the +# human-readable counterexample.txt per cell plus the sweep summaries. +trace.json diff --git a/formal/GLOSSARY.md b/formal/GLOSSARY.md new file mode 100644 index 000000000..8eaf02b6e --- /dev/null +++ b/formal/GLOSSARY.md @@ -0,0 +1,209 @@ +# Glossary — sync scheduling formal model (deliverable 0) + +Pinned vocabulary for the model, its documents, and its P identifiers. +Where a term names something that exists in code today, the anchor is +cited; graph-runtime terms describe CANDIDATE semantics under evaluation +(see `docs/tasks/demand-graph-sync-brief.md`) and are definitions of what +the model checks, not descriptions of shipped behavior. + +## Shared vocabulary + +- **Sync**: the logical unit of work that produces one artifact. Identified + by a sync ID; spans one or more attempts. +- **Attempt**: one process execution of a sync. A crash or interrupt ends + an attempt; a resume starts a new attempt of the same sync from its last + durable checkpoint. The **attempt boundary** is the crash/resume seam. +- **Artifact**: the durable output of a sync (a c1z): row partitions, a + manifest, and — once sealed — a completion verdict. The **previous + artifact** is an immutable, read-only replay base consulted only via the + lookup. +- **Row**: one stored record (resource, entitlement, or grant — the model + abstracts these to one row kind axis). Row identity is its storage + identity within a row kind. +- **Scope / output key**: the stable storage identity a partition is keyed + by. In the walker this is the connector-chosen `(row_kind, scope_key)` + (`annotation_source_cache.proto`); in the graph runtime it is the node's + output key. Deliberately distinct from the derivation hash (scheduling + identity): re-derived work must land in the same partition. +- **Partition**: the set of current-sync rows stamped with one scope. + **Partition invariant**: scopes partition rows — each row identity + belongs to exactly one scope per sync; a cross-scope restamp or + out-of-scope delete is a partition violation and poisons the losing + scope (proto contract). +- **Validator**: the opaque upstream change-detection token persisted per + scope (HTTP ETag, delta token). **Truthful-validator assumption** (trust + boundary): a validator matches iff the scope's upstream content is + unchanged. +- **Manifest**: the artifact's map of scope → manifest entry (validator, + plus a sealed row count). An entry is published only after its page's + rows and tombstones commit. +- **Attestation**: the claim a manifest entry makes: this artifact's + partition for scope S equals replay-of-the-attested-base plus the + declared compositions (overlay upserts, tombstones, or replacement), + produced under validator V. P1 (binding integrity) is the integrity of + this claim. +- **Consult**: resolving a scope's freshness this sync: a lookup against + the previous artifact's manifest, then — on a hit — connector + revalidation of the validator against upstream. A scope was "consulted + against upstream during sync N" if its verdict came from revalidation or + fresh fetch within sync N. +- **Hit**: a warm-lookup consult that found a manifest entry. Recorded + with its validator in the checkpoint-durable hit map + (`state.sourceCacheHits`, CO-6b-004). +- **Record**: fresh-fetched rows stamped into a scope's partition, with a + validator publish when the page carries one (`SourceCacheRecord`). +- **Replay**: copying the previous artifact's partition for a scope into + the current sync (`SourceCacheReplay`). +- **Elision**: what replay skips — the enumeration the connector would + have performed for the scope. Replay copies rows, not side effects: + session writes (and reads) the elided enumeration would have made do + not occur this sync. Elision is sound only if the enumeration is + side-effect-free beyond its rows (model spec scenario 7). +- **Replacement**: the replay copy's semantics — the destination partition + is cleared, then the base is copied + (`clearReplayDestinationScopeLocked`). Contrast **overlay**: upserts and + tombstones applied on top of a replayed base (delta semantics). +- **Composition enum (proposed)**: a `SourceCacheRecord` marker declaring + OVERLAY vs REPLACES semantics for a page's contribution; REPLACES blocks + the artifact as a future replay seed until supersede machinery exists + (deliverable 3 models this staged mitigation). +- **Poison**: a durable per-scope marker recording a partition violation. + A poisoned scope reads as a lookup miss and is refused as a replay + source (preflight). +- **Preflight**: source-side validation before a replay copy: manifest + entry present and not invalidated, scope not poisoned, sealed row count + equals the index cardinality with stamp verification + (`validateReplaySourceScope`). +- **Checkpoint**: the durable snapshot of scheduler state — action stack, + provenance sets, flags — written between dispatch batches + (`state.Marshal` → sync token), and FORCE-written at Init, before seal, + and on graceful stop (`checkpointOnStop`, run-expiry). A stop-forced + checkpoint captures live mid-batch state: mid-chain cursors of + unfinished actions, admitted-but-undrained spawns, and hits recorded + during the aborted batch. Resume restores exactly the checkpoint and + nothing else; all other scheduler state is volatile. +- **Seal**: the transition that completes a sync's artifact (EndSync). + Sealed row counts are stamped before the end stamp; after seal the + artifact is immutable. **Seal obligations** are the checks that must + hold at this point. +- **Warm / cold**: warm = a previous-artifact lookup is installed (every + consume gate G1–G7 passed, this attempt); cold = `NoopLookup`, every + consult misses. Degradation to cold is always safe; it costs caching + value only. +- **Compat key**: the four-field byte-matched record gating warm installs + (connector cache generation, config fingerprint, SDK materialization + generation, selection fingerprint — plan B4). Two artifacts from the + same connector and config share a compat key; this is why validator + binding (CO-6b-004) exists. +- **Smear**: the baseline time-inconsistency of any paginated walk: + different scopes observe upstream at different instants, so every + artifact is a mixture of upstream states that existed during the sync. + Smear is not a defect; P3 bounds which mixtures are acceptable. + +## Walker-specific + +- **Action**: the checkpointed unit of scheduled work: op, page token, + resource keying, spawn/type-scope markers (`state.Action`). The stack is + LIFO by admission order; per-resource phases dispatch batches of up to + 100 consecutive same-op actions to bounded workers. +- **Spawn vs continuation**: `EnqueuePageTokens` ADMITS new sibling cursor + actions — each an independently checkpointed, schedulable identity, + deduplicated per process by identity digest. `NextPageToken` advances + the SAME action's cursor in place. Spawn creates schedulable identity; + continuation does not. +- **Restart-from-root (CO-6b-002)**: resume restores actions as of the + MOST RECENT durable checkpoint. In crash-only histories that is a + loop-top/forced checkpoint holding only root tokens, so an + interrupted paginated action re-executes from its root token; under + a graceful stop the forced stop-checkpoint may capture a mid-chain + cursor, and resume continues from it — including when that + checkpoint survives a LATER hard crash. Restart-from-root is a + property of which checkpoint survives, not of the crash itself. Page + processing is at-least-once across an attempt boundary in all modes. +- **Hit-set / replayed-set**: the checkpoint-durable, within-sync-monotone + provenance maps. The hit-set (row kind → scope → validator) authorizes + same-sync replays; the replayed-set dedups the once-per-sync replacement + copy. Hits recorded in the dispatch batch that crashes are lost with it + (CO-6b-006). +- **Warm gate (attempt-scoped)**: the `sourceCacheWarm` flag — set only + after THIS attempt installed a deliverable warm lookup; consulted before + every replay copy. A restored hit-set does not re-authorize replay in a + cold or drifted resume (CO-6b-003). +- **Scope lock**: the per-(row kind, scope) mutex every scoped page holds + from before its row puts through its validator publish (CO-6b-005/006); + closes the duplicate-copy TOCTOU and the record-page/replacement-copy + interleaving. + +## Graph-runtime (candidate semantics) + +- **Node**: a re-issuable request description (call site + parameters). + Persistent scheduling identity; may be executed any number of times. +- **Execution**: one attempt of one node. Identified by (node, + generation). +- **Generation**: a node's restart counter. An output produced by + execution (n, g) is **dead** once n restarts into generation g' > g. +- **Derivation hash**: the canonical hash of a node's request derivation; + the scheduling identity used for revisit suppression. Distinct from the + output key by design. +- **Spawn lineage**: the single-parent tree of which execution admitted + which node; used for eager purge of a restarted node's spawn-subtree + (variant E). +- **Support / data lineage**: refcounted demand edges recording which + outputs support which rows and nodes; DERIVED, not stored; retraction is + transitive when support drops to zero (variant E). +- **Demand closure**: the set of nodes and outputs transitively demanded + from the sync's roots as of seal time. +- **Sweep**: the seal-time pass that drops every partition outside the + final demand closure and nothing inside it (P5). +- **Fresh-artifact supersession**: a newer execution's outputs replace an + older generation's outputs for the same output key, rather than + composing with them. +- **Causal stamp (variant S)**: a compact causal timestamp over node + generations carried by every output (rows, session values, spawned + tokens). Reads merge the value's stamp into the reader's; writes carry + the writer's merged stamp; validation happens at observation points + (demand derivation, session reads, seal). Lossy compression is + admissible because the error direction is false staleness → redone + work, never wrong data. +- **Consistent cut (variant S)**: the variant-S form of P1/P3: no + published partition mixes outputs from causally incomparable + generations, checkable mechanically from stamps at seal. +- **Sealed cut (P7)**: the checkpointable fact "no pending or reachable + node can emit row-kind K" — the closure precondition grant expansion's + aggregate node requires before condensing. + +## Session store + +- **Variant A (shipped)**: free-form KV, sync-scoped, durable across + attempt boundaries (`pkg/types/sessions`, + `pkg/dotc1z/engine/pebble/session_store.go`). Any execution may read any + key; no lineage is recorded — the dependency channel in calibration + case 2. +- **Variant B (proposed primitives)**: private scratch (readable only by + its own execution, dies with the execution's generation); single-writer + publish (reads are tracked edges; the writer's re-derivation retracts + readers); keyed-contribution merge (per-writer retraction). +- **Session taint (proposed)**: produce-side marking that a kind's + enumeration touched the session store during a replay-capable phase + (replay-capable = the kind is in the declared source-cache flow, + regardless of the recording attempt's warm/cold state), recorded in + the artifact's produce state (checkpoint-cadence durability, + self-healing under at-least-once re-execution); a tainted kind's + scopes read as lookup misses in later syncs — degradation, never a + loud verdict. Write-only taint closes the elision hole (scenario 7a) + but not the stale-read dual (7b); full-traffic taint (session + isolation) closes both. A capability-level opt-out — the connector + attests emission-irrelevance of its session traffic — disables the + detector for those kinds; trust-boundary machinery, and a dishonest + opt-out reproduces 7a/7b exactly. + +## The three-invariant framing + +- **Demand-gating**: nothing outside the final demand closure is + published (consume/sweep side; P5). +- **Validator-gating**: every published row entered via a fetch or a + replay whose validator was consulted against upstream during this sync + (P2). +- **Binding integrity**: every manifest entry attests exactly its + partition's declared composition over the attested base (P1, + produce-time). diff --git a/formal/GRAPH_MODEL_SPEC.md b/formal/GRAPH_MODEL_SPEC.md new file mode 100644 index 000000000..6b0fb8921 --- /dev/null +++ b/formal/GRAPH_MODEL_SPEC.md @@ -0,0 +1,878 @@ +# Model spec — demand-graph runtime model (P), deliverable 4 + +Status: v4, FROZEN. Review history: round 1 +(`formal/reviews/graph-spec-round1.md`) REJECTed v1 with 11 majors, +all dispositioned in v2. Round 2, targeted on the adoption repair +(`formal/reviews/graph-spec-round2-adoption.md`), verified the +adoption core sound and REJECTed on 6 seam majors, all dispositioned +in v3. Round 3, targeted on the v3 repairs +(`formal/reviews/graph-spec-round3-repairs.md`), verified ALL six +round-2 repairs soundly applied and REJECTed with 2 majors + 4 minors ++ 3 notes — every finding fix-without-re-review, no re-review +required ("the fixed spec needs a disposition registration check, not +a fourth adversarial round"). v4 applies the round-3 dispositions +(§12) and freezes: subsequent changes are GS-CO-NNN change orders, +never silent edits. Companion and baseline: `formal/MODEL_SPEC.md` +(v11 FROZEN + MS-CO-001); `formal/GLOSSARY.md`; +`docs/tasks/sync-formal-model-brief.md` (charter, deliverable 4); +`docs/tasks/demand-graph-sync-brief.md`. + +Purpose, stated narrowly: (a) re-check the walker's calibration bug +premises against the graph runtime's candidate semantics, (b) check +the NEW property obligations the graph introduces (P5 sweep soundness, +the laundering oracle and its per-variant mechanisms), and (c) +ARBITRATE THE LINEAGE BAKE-OFF — variant E (eager edges) versus +variant S (observable-causal stamps) — by checker output on property +satisfaction, mechanism count (frozen tally, §7.5), and redo work +under the divergence scripts (§9 G6). The written recommendation is +the artifact the demand-graph RFC cites, assembled under §10.7's +frozen decision rule. Refutation of a candidate invariant is a +success. + +## 1. What is modeled, what is abstracted + +Modeled (the graph runtime's candidate scheduling semantics): + +- A frontier scheduler: nodes as re-issuable requests, executions as + (node, generation), revisit suppression by derivation hash (with + the death semantics of G-RULE-2, round-2 R2-F5), demand derivation + from emissions, frontier checkpoint, resume with generation bumps, + seal-time sweep to the final demand closure, fresh-artifact + supersession with a total interaction matrix incl. marker lifecycle + (§4b). +- BOTH lineage variants as first-class scheduler modes sharing every + other mechanism: E = spawn lineage pending-purge (∀-predicate, §3) + + refcounted support DAG + session reads as tracked edges (requires + session variant B); S = causal stamps merged on read, validated at + the declared observation points (§3), nothing eagerly retracted. +- The session store as a dependency channel, variants A and B. +- Crash/resume at every boundary (armed injection), graceful stop, + the forced resume checkpoint (§5), MID-ATTEMPT generation death + under the quiesce-before-bump rule (§3, round-2 R2-F1), upstream + mutation between attempts and between syncs, bounded workers (2; + the G1d cell scripts 3 so the retraction-forced re-run dispatches + AT the bump — with 2 the dying-reader race needs two consecutive + starvation phases and random search cannot reach the declared + alarm; calibration scripting note, logged). +- Source-cache consult/replay/record inside node executions using + unit-mode materialization (MODEL_SPEC §9.6, settled hand-off), + adapted by §4a's premise-validated adoption with the round-2 + eligibility pins (MATCH-only, writer-ineligible). + +Abstracted, beyond MODEL_SPEC §1's list: + +- Budgets and magnitudes (attempt-level failure and the ladder ARE in + scope, §3/§8; per-node work budgets are not). +- Grant expansion / the aggregate node: de-scoped from this + deliverable (v2; deliverable 5 owns sealed cuts). +- The sessions × replay product (walker scenario-7 class): the + CROSS-SYNC product stays excluded with argument (v2, §12 F17 + entry); cross-sync stamp travel pinned in §4c; the walker cells + own taint. The WITHIN-SYNC product is now governed by the §3 + SESSION-PUBLISH BODY-OP PIN (round-3 R3-F1): in this model, + session publishes are node-body store ops executed by every + non-adopted execution regardless of verdict class — a declared + within-sync deviation from the walker's elision vocabulary, + load-bearing for the writer-ineligibility convergence argument + and for the `writerAdopt` kill's fireability (under the elision + reading a replay-verdict re-derivation would strand a dead + publish on an honest flap-back history and the kill could never + fire). If the runtime design adopts elision-style replay for + publish-bearing nodes, that is a change order with its own cells. +- SESSIONS × DEMAND SHRINK (round-3 R3-M4): a writer legitimately + de-demanded by an epoch shrink never re-publishes, and a + still-demanded reader of its sync-scoped value would carry an + uncleanable dead component under S. No scripted cell composes + sessions with a shrink; the shape is EXCLUDED from the envelope + and stated in §8's inductive bet, and §4a's convergence claim is + scoped to the scripted envelope accordingly. +- PUBLISH-DERIVED DEMAND (round-2 R2-M6(iii) + R2-F2 facet): demand + derivation in this model is a pure function of ROW CONTENT only. + Session publishes are dependency-channel machinery (P6-G's + jurisdiction), never demand sources. This is a declared restriction + of G-RULE-1's vocabulary: a runtime capability to demand work from + a session publish is NOT modeled, and if the design adopts one it + needs its own cells (change order). +- SESSION-TRANSITIVE RETRACTION CHAINS (reader-writer nodes; round-2 + R2-M6(ii)): excluded from the envelope and stated in the inductive + bet (§8) — the retraction rule is keying-uniform, so chains add + length, not mechanism; a reader-writer config is deferred to the + RFC stage if the recommendation's session story needs it. +- The walker itself (mapping in §5; divergences are honest deltas). + +## 2. Ground rules the encoding must obey + +All of MODEL_SPEC §2 carries over verbatim (arrival order a genuine +choice point; crash wipes exactly §5's volatile rows; announce-only +monitors; truthful validators; non-lying connectors; expected +verdicts declared before first run). + +Graph-specific rules: + +- G-RULE-1 (structure rides emissions): demand derivation is a pure + function of announced ROW CONTENT (the child-marker row; §1's + publish-derived-demand exclusion). TIMING PIN: derivation is + per-announce, atomic with that announce's completion-bookkeeping + effects. DERIVED-ANNOUNCE CARRIER PIN (round-2 R2-M2): scheduler + events with monitor significance that arise from processing an + announce (mid-attempt `eAnnGenBump`, retraction re-admissions, + observation-forced re-runs, forced-redo counts) are emitted as + DERIVED ANNOUNCES within the atomic processing of their carrier + announce, so monitors observe them in commit order; resume-time + bumps ride the forced resume checkpoint's commit (unchanged). +- G-RULE-2 (derivation hash is the ONLY suppression key, WITH death + semantics — round-2 R2-F5): the scheduler MUST suppress an + admission iff the same derivation hash's node is currently PENDING + or COMPLETED this sync ("may" is deleted — the checker cannot + legally choose starvation). PURGE AND REFUSAL-DROP REMOVE the + node's derivation hash from the admitted-derivation set, making a + live re-derivation re-admissible. Output keys never suppress; the + distinct-derivation same-key shape is §4b's poison row. RESUME + RULE: completed iff admitted ∧ ¬pending, evaluated AFTER any + purge/refusal removals of the resume. +- G-RULE-3 (generations are per-node monotone counters, durably + fenced): execution (n, g) exists only after every (n, g' < g) is + dead; an output's producing generation is stamped at emission and + never reassigned (`eAdopt` is a recorded transfer). Identity + uniqueness is monitored (P-GEN, §7; rule per R2-N3: no two + attempts contain store-commit announces attributed to the same + (n, g); adoption re-announces attribute to the ADOPTING execution). + (GS-CO-001) The durable fence is TOTAL over every minting path: no + generation dispatches before the table delta that minted it is + durably committed — (a) the attempt-start root mint (rides the + forced-resume-checkpoint discipline; a crash before any checkpoint + otherwise cold-restarts and re-mints attempt 1's identities), (b) + the first-admission mid-attempt mint of a newly demanded node + (rides the mid-bump fence; a crash after the node's first store + commit but before any checkpoint otherwise re-mints it), (c) the + resume bump (F4), (d) the mid-attempt bump (R3-F2). Calibration + found (a) and (b): P-GEN reds an HONEST single-crash history + without them. +- G-RULE-4 (the frontier checkpoint is total): pending nodes (id, + derivation hash, output key, generation, round-boundary cursor), + the admitted-derivation set, generation-qualified admitted-by + edges, closed-cut facts, the session index per variant. Variant + E's support counts are derived; the resume rebuild target is the + CHECKPOINT-CONSISTENT value; the rebuild-agreement monitor checks + that value. + +## 3. Machines + +Reused from MODEL_SPEC §3 (re-declared in `formal/graph/`): MUpstream, +MStore, MCrashInjector, MEnv. MStore's registered op vocabulary: +`eCheckpoint`, `eLookup`, `eGateRead`, `eClearScope`, `eUpsertPage` +(with composition intent REPLACES/OVERLAY), `eTombstones`, +`ePublishEntry`, `eSessionGet/Set` + variant-B primitive ops, `eSeal`, +`eReplayUnit(key)` / `eOverlayUnit(key)`, marker ops +(`eMarkerPut(key, gen, premise, publishBearing)` / marker read — the +marker records whether its round performed session publishes, §4a), +`eAdopt(key, fromGen, toGen)` (PRECONDITIONS, store-side: fromGen is +DEAD (round-2 R2-N1; the one mutant-reachable live-fromGen adoption — +`suppressionOff`'s sequential schedule — is a declared deviation +whose legality alarm still derives) AND the key is NOT POISONED +(round-3 R3-M2: the poison-voids-marker rule is enforced at the +`eAdopt` commit, not only at the worker-side marker check, closing +the check-then-act window against a concurrently landing poison)). CLEAR-PLACEMENT PIN: +`eClearScope` commits only as the first store op of a REPLACES-intent +round; it also DELETES the key's marker (round-2 R2-F4 — marker +lifecycle rides the clear). MARKER SCOPING PIN (round-2 R2-M3): +markers are PER-SYNC scheduling state — the §4a marker check reads +the CURRENT sync's store only (the walker 3-atomic precedent made +explicit), and seal DROPS marker rows from the sealed artifact +(markers never travel cross-sync; consult provenance cross-sync is +the manifest, as everywhere). + +### MGraphScheduler (one per attempt) + +Owns: frontier, admitted-derivation set, admitted-by edges, +generation table, demand derivation, lineage state per variant, +dispatch to 2 workers. + +Dispatch loop: pick a frontier node, issue (n, g), process announces +per-announce (G-RULE-1), checkpoint (placement a choice point), seal +when the frontier drains. + +MID-ATTEMPT DEATH — QUIESCE-BEFORE-BUMP (round-2 R2-F1, the walker +decision-16 precedent): a mid-attempt generation bump (retraction- or +observation-forced) commits only when the dying generation's +execution is NOT in flight; if it is, the bump DEFERS until that +execution's completion announce and is processed atomically with it +(derived announce). Consequence, pinned: a deferred bump orders the +forced re-run AFTER the dead execution's late commits, so the +re-derivation is the last writer and no dead unit can wipe live rows. +The dead-in-flight interleave is a probe cell (G1d, expected +unreachable-after-pin; `quiesceOff` kills it). Non-interference +(round-3 R3-N2, recorded): a deferred bump cannot starve the pass +budget — deferral requires an in-flight dying execution, hence a +non-drained frontier, and the pass only scans a drained frontier, so +every deferral resolves strictly before the pass's first scan; two +workers' deferrals cannot deadlock — a deferral waits on an +execution's completion and no completion ever waits on a bump, so +the wait graph is one-directional. + +MID-BUMP FENCE (round-3 R3-F2 — the F4 durability discipline +extended to mid-attempt minting): a mid-attempt bump's +generation-table delta is durable BEFORE the bumped generation +dispatches — the bump forces an `eCheckpoint` commit (the checkpoint +carries the generation table, G-RULE-4) between the bump's carrier +announce and the new generation's first dispatch. Without it, a +crash landing after the bumped generation's first durable commit +with the elective checkpoint skipped would re-mint the same id from +the restored table (round-1 F4's hazard through the retraction +path). Probe cell G1e; `midBumpFenceOff` kills it (P-GEN RED). + +RETRACTION QUEUE (E; semantics pinned per R2-F1's disposition): +processing a re-publish announce ENQUEUES (as derived effects) a +retraction entry per reader execution of the now-dead value (keyed +per MSessionStore's pin); each entry re-admits the reader node +(bump + re-admit, quiesce-deferred as above) and is removed when the +re-admitted execution completes. The pre-seal condition for E is an +empty retraction queue. + +OBSERVATION POINTS (S): (i) DEMAND-DERIVATION refusal — a pending +node whose admission stamp contains a dead generation is re-validated +at dispatch: run under a live re-derivation if one has re-derived the +hash, else dropped from the frontier (and its hash removed, +G-RULE-2). (ii) SESSION-READ (round-2 R2-M1, registered): a read +returning a dead-stamped value proceeds (read-through) and emits a +derived dead-read announce that feeds the forced-redo count; no +scheduling effect is needed — the dead value's writer is pending by +construction (its death was a bump that re-admitted it; invariant +stated here, checkable). (iii) PRE-SEAL PASS: scan sealed-bound +outputs; any dead-generation stamp forces the producing node's re-run +(bump + re-admit, derived announces); iterate up to the §8 +PASS-ITERATION BUDGET (round-2 R2-M7 — the bound is an explicit +budget row, not "finite by construction"; convergence within budget +is a CHECKED expectation of every honest cell, via the no-dead-stamps +seal form of P6-S, and a budget-exhausted seal is announce-visible). +ITERATION BOUNDARY (round-3 R3-M3): one iteration = one scan over a +DRAINED frontier — a forced re-admission un-drains it, and the next +scan begins only after it re-drains; the budget counts scans, never +mid-flight re-observations. + +SEAL SEQUENCE: frontier drained → pre-seal pass (S) / retraction +queue empty (E) → SWEEP → `eSeal`. + +Resume: restore checkpoint; bump every pending node (prior generation +dead); commit the FORCED RESUME CHECKPOINT before any dispatch (§5); +then dispatch. Variant E purges pending nodes under the ∀-PREDICATE +(round-2 R2-F5: purge only when EVERY admitted-by edge names a dead +generation — the refcount-consistent reading), removing purged +hashes from the admitted-derivation set. Variant S refuses at +dispatch time per observation point (i). + +ATTEMPT FAILURE (walker parity): a loud node failure fails the +attempt; the scheduler checkpoints, announces the failure with its +GENERATION-BLIND fingerprint (failure point, reason, restored state +modulo the generation table), and MEnv resumes or abandons per the +ladder. + +### MNodeExec (worker-side execution body) + +One execution = marker check (§4a) → consult → verdict (ADOPT is a +REGISTERED VERDICT CLASS in the announce vocabulary, round-2 R2-F3 — +alongside replay / changed-with-diff / fetch-fresh) → emissions. +Unit-mode materialization for replay and diff rounds; record rounds +for fetch-fresh (no marker — G8a pin). SESSION-PUBLISH BODY-OP PIN +(round-3 R3-F1): a node's session publishes/contributes are BODY +STORE OPS executed by every NON-ADOPTED execution regardless of +verdict class — a replay-verdict re-derivation re-publishes; only +adoption skips session ops, which is exactly what the +writer-ineligibility bit exists to prevent. This is the reading +round 2's accepted walks used, registered; it is a within-sync +deviation from the walker's elision vocabulary (§1's boundary +sentence), and it is what makes the writer flap-back history +converge (the MATCH-verdict re-derivation re-publishes under its +live generation, the writer-stamp delta re-derives every reader). Under variant S the +execution's stamp initializes {n: g} and merges every session value's +stamp it reads; ADOPTING executions' premise re-reads REGISTER +normally (round-2 R2-M5: tracked read edges under E+B, stamp merge +under S, attributed to the adopting execution). + +### MSessionStore + +Variant A: free-form KV. Variant B: scratch / publish / contribute; +publish-retraction keyed by (session key, value identity, writer +generation); a re-publish retracts every reader execution of a dead +value, including re-runs that read a stale value before the +re-publish landed (witnessed by G2's G-pending leg, round-2 +R2-M6(i)). + +## 4. Node execution and store interaction + +### 4a. Premise-validated adoption (round-1 F1 repair + round-2 eligibility pins; round-3 review target) + +- The marker is a memoization entry: `eMarkerPut` commits (key, + producing generation, premise digest, publishBearing bit) inside + the unit. The premise digest is the canonical hash of the consult + result (previous-artifact entry + revalidation OUTCOME AND MATCHED + VALIDATOR) and the identity+writer-stamp of every session value + read before unit commit. DIGEST CLOSURE (round-2 R2-N2): the + digest is total over the MODEL'S verdict inputs — consult result + and session reads; config/compat and warm/cold state are constants + in every cell of this spec, so their omission is declared vacuity, + not an escape (a drift-modeling extension must extend the digest + by change order). +- A re-execution finding a marker for its output key recomputes the + premises (re-consult; session re-reads). ADOPTION ELIGIBILITY + (round-2 pins, both load-bearing): + - MATCH-ONLY (R2-F3): adoption requires the re-consult's + revalidation to MATCH. A FAILED revalidation re-derives + regardless of the stored digest — FAIL means upstream moved, the + prior FAIL-verdict's fetched content is not re-attested by + anything current, and a FAIL-vs-FAIL digest equality is an + outcome-bit coincidence (the e1→e2→e3 escape, R2-F3's history; + probe cell G1c). With this pin the §7 freshness claim is TRUE: + every adoption's qualifying consult is the adopting MATCH + itself, this attempt. + - WRITER-INELIGIBILITY (R2-F2, the round-2 re-review target): a + marker whose publishBearing bit is set NEVER adopts — a dead + writer re-derives always. Rationale, pinned: adoption re-grounds + ROWS ONLY; a dead generation's session publishes cannot be + re-grounded by any rows-only mechanism, and a stranded dead + publish defeats the observation pass's progress (readers re-adopt + through unchanged premises forever — R2-F2's loop). Under this + pin the dead-publish state is TRANSIENT by construction: the + writer's forced re-derivation re-publishes under its live + generation (same value or not — true for EVERY verdict class + including replay, per the §3 body-op pin, round-3 R3-F1), + retraction (E+B) or the stamp + delta (S: writer stamp g_dead → g_live differs → reader digest + differs → re-derive) clears every reader, and the pre-seal pass + CONVERGES within the iteration budget on every honest history OF + THE SCRIPTED ENVELOPE (round-3 R3-M4's scoping: the sessions × + demand-shrink shape, where a de-demanded writer never + re-publishes, is excluded by declaration — §1/§8) — + the convergence argument the round-2 charge question 5 found + missing, verified mechanically by round 3 (every honest walk + converges in ≤ 2 of the budgeted 3 iterations; the at-least-once + cost claim verified honest, R3-N1: count-legal, + suppression-safe, verdict-neutral). + Cost: writers never amortize across death — recorded as + forced-redo count in the bake-off, safety-neutral. + - Digest EQUAL (and eligible) → ADOPT: one atomic `eAdopt` — + stamps rewritten to the live generation (S), fold/count transfer + (§4d), marker generation updated, stored rows re-announced under + the adopting execution's attribution. Rows only; adoption- + eligible rounds have no session writes by the eligibility bit, + so rows-only re-announce is TOTAL over what the round emitted. + - Digest DIFFERENT or ineligible → RE-DERIVE: the execution + proceeds to its verdict as if unmarked. Its superseding round + clears per §4b — a UNIT round's `eMarkerPut` constituent + overwrites the marker; a RECORD round's `eClearScope` deletes it + (round-2 R2-F4's text correction: fetch-fresh re-derivations are + record rounds and carry no `eMarkerPut`). +- Walker coherence: for MATCH premises with no session inputs, + adopt-on-equal is observationally the walker's clause (iii), + strictly fresher (the adopting MATCH qualifies under the F8 pin) — + round 2 verified this degeneration argument correct for the MATCH + shape; the FAIL shape is now excluded by eligibility rather than + overclaimed. + +### 4b. Supersession and marker lifecycle — the total matrix + +Rows and markers, total over {existing rows dead vs live} × +{incoming unit vs record} × {REPLACES vs OVERLAY intent}, with the +MARKER COLUMN (round-2 R2-F4): + +| existing | incoming | rows | marker | +|---|---|---|---| +| dead rows | unit (replay/overlay) | clear constituent removes them; fold/count contribution removed (§4d) | `eMarkerPut` constituent overwrites (new gen + digest + bit) | +| dead rows | record REPLACES | `eClearScope` removes them; contribution removed | `eClearScope` DELETES the marker (§3 pin) | +| dead rows | record OVERLAY-intent | ILLEGAL under the trust model (base-liveness precondition): overlay composes only over a live base; scripted connector policies never produce it and — for record-over-record keys, which carry NO marker — the precondition rests entirely on scripted policy + the trust model (round-2 R2-M4's honest wording; the `overlayComposeDead` MUTANT is the load-bearing check: expected P1-CONTENT red on epoch divergence + P6-S dead-stamp red under S) | n/a (no marker on record keys) | +| live rows (same derivation) | any | round continuation / at-least-once redo | unit rounds refresh it; record rounds have none | +| live rows (distinct derivation hash, same key) | any | CONNECTOR-CONTRACT VIOLATION: store poisons the scope on the second derivation's first commit; P1 legality EXEMPTS poisoned scopes (the poison is the alarm); seal excludes the scope (SealExpect) | POISON VOIDS the key's marker (round-2 R2-M8): no adoption of poisoned content is ever legal; post-poison rounds for the key commit legally but the scope stays seal-excluded | + +MARKER INVARIANT (round-2 R2-F4, monitored as P-MARK, §7): a marker +present for a key ⟹ the key's current partition equals the marked +round's committed outputs. Every matrix row above preserves it; the +flap-back history that violated it in v2 (record re-derivation +stranding a stale marker, later premise flap-back adopting content +the marker no longer described) is unreachable after the +clear-deletes-marker pin — probe cell G8d, `markerCleanupOff` kill. + +### 4c. Cross-sync stamps + +RESTAMP-ON-REPLAY: REPLAYED rows (cross-sync copies) carry the +replaying execution's stamp; the source artifact's own seal +discharged its internal provenance. (v2's "adopted-across-sync" +wording deleted — adoption is WITHIN-SYNC only; markers are per-sync, +§3.) Cross-sync session-stamp travel remains walker P6-R +jurisdiction. + +### 4d. Fold and count grounding over generations + +Unchanged from v2 (round-2 verified the back-port coherent and the +removal clause correctly DEATH-GATED — a live-rows removal reading +would dissolve walker cell 4's alarm; the gate is load-bearing, +stated here per the round-2 caveat): a generation's complete round +stays in fold and count until ADOPTED (contribution transfers) or +SUPERSEDED (§4b removal). The v2 incoherence (transferring a removed +contribution) is unreachable once §4b's marker column exists. + +## 5. Durability, crash, and resume semantics + +Unchanged from v2 except: the marker row now reads "(key, generation, +premise digest, publishBearing)" and is per-sync (dropped at seal, +§3); the forced-resume-checkpoint row is unchanged (round-2 verified +F4 applied correctly and P-GEN checkable per R2-N3's recorded rule); +mid-attempt bumps' SCHEDULING EFFECT is volatile and its loss is +self-healing (the triggering re-publish or observation re-fires on +the resumed attempt — at-least-once), with their announces carried +per G-RULE-1's derived-announce pin — but the bump's +GENERATION-TABLE DELTA is NOT self-healing against id reuse and is +durably fenced by the §3 MID-BUMP FENCE before the bumped +generation's first dispatch (round-3 R3-F2: "self-healing" is true +for the loss of the bump's scheduling effect, never for the minted +id). + +| state | machine | durability | +|---|---|---| +| partitions, manifest, poison, session KV, seal flag | MStore | durable at op commit | +| unit marker (key, gen, digest, publishBearing) | MStore | durable at op commit; per-sync (seal drops); deleted by REPLACES clear; voided by poison | +| frontier checkpoint (per G-RULE-4) | MStore | durable at eCheckpoint commit | +| forced resume checkpoint | MStore | restore → bump → eCheckpoint commit → dispatch (P-GEN's ground) | +| in-flight execution state | MNodeExec | volatile vs crash; vs mid-attempt death, quiesce-before-bump defers the bump (§3) | +| derived support counts (E) | MGraphScheduler | volatile; checkpoint-consistent rebuild target | +| retraction queue (E), pass state (S) | MGraphScheduler | volatile; self-healing at-least-once (re-publish / re-observation on resume) | +| mid-attempt bump table delta | MStore (via forced eCheckpoint) | durable BEFORE the bumped generation dispatches (§3 MID-BUMP FENCE, R3-F2) | +| causal stamps (S) | ride outputs | durable where the output is; `eAdopt` rewrites atomically | +| generation table | MGraphScheduler | latest-per-pending in checkpoints; death announce-visible (`eAnnGenBump` at carrier commits) | + +Walker→graph mapping: unchanged from v2 (review-verified accurate). + +## 6. Variant axes and mutation toggles + +Axes and defaults unchanged from v2 (lineage per-leg; session A +default, vacuous outside G2/G9; compression off outside G9). + +| toggle | what it removes/injects | kill cell | expected flip | +|---|---|---|---| +| `suppressionOff` | G-RULE-2 admission suppression | G1 mutant leg / G4 | P1-LEGALITY first-find (racing schedules; sequential adopts — live-fromGen deviation per R2-N1) | +| `sweepOff` | seal-time sweep | G5b | P5-UNDER (+ P6-S under S) | +| `sweepOverreach` | sweep drops in-closure partition | G5c | P5-OVER + P1-CONTENT | +| `purgeOff` (E) | pending-purge on death | G5e | execution-count oracle (redo machinery; seal stays green) | +| `stampMergeOff` (S) | read-side stamp merge | G2-S legs | P6-G RED (oracle, mechanism-independent) | +| `retractionOff` (E+B) | re-publish reader retraction | G2 E+B leg | P6-G RED | +| `overlayComposeDead` | §4b base-liveness precondition | G8b mutant leg | P1-CONTENT + P6-S (S) | +| `resumeCkptOff` | forced resume checkpoint | G1b | P-GEN RED | +| `demandDropOff` | drops one derived admission | G5f | closure oracle RED (SealExpect) | +| `adoptOnFail` | removes MATCH-only eligibility | G1c mutant leg | P-ADOPT RED (GS-CO-002: the smuggled rows(e2) sits INSIDE the sync-scoped freshness envelope, so no artifact-level oracle can see it; SealExpect stays GREEN by design — a declared control) | +| `writerAdopt` | removes writer-ineligibility | G2 announce-window legs | S: P6-S RED at seal (pass exhausts its budget against the stranded dead publish — R2-F2's loop, now a kill); E+B: P6-E RED (no re-publish, readers never retracted) | +| `quiesceOff` | quiesce-before-bump | G1d | P6-G RED (dead in-flight unit's late clear wipes the live re-derivation — R2-F1's walk, now a kill) | +| `midBumpFenceOff` | §3 mid-bump fence (checkpoint-at-bump) | G1e | P-GEN RED (two-crash id reuse — R3-F2's walk, now a kill; mirrors G1b/`resumeCkptOff`) | +| `markerCleanupOff` | REPLACES clear deletes marker | G8d | P-MARK RED (stale marker survives a record supersession; the flap-back then adopts mismatched content — P3′ RED under E) | + +## 7. Properties (checkable forms) + +[Post-freeze editorial, two-track seam: the composition algebra the +fold pins assume (L1–L6) and the stamp-lattice laws the S variant +rests on — merge as a join-semilattice, dead-membership +homomorphism, floor-compression staleness soundness (L7–L9) — are +mechanically proved in `formal/occult/LAWS.md`; the model consumes +them as assumptions per the brief's division of labor. No semantic +change.] + +P1/P2/P4 as in v2 (P1 with §4d grounding + poison exemption; P2's +qualifying consult for adopted scopes is the adopting MATCH — true +under MATCH-only eligibility; P4 with the generation-blind +fingerprint). P3′ is the walker form, honestly named (v2 pin). + +- P5 + CLOSURE ORACLE: unchanged from v2 (ghost closure from live + announces; env-side counterfactual SealExpect as the independent + base; round 2 confirmed the independence is real — the oracle is + what catches R2-F5's starvation, now repaired). (GS-CO-002) + SealExpect content is SYNC-SCOPED: the env announces the live + per-key world at EVERY attempt start and the monitor accumulates + the sync's acceptable epoch SET; sealed content must match SOME + attempt-start world. Calibration find G1-CAL-1: a key whose + derivation completed and checkpointed before a crash legitimately + seals the earlier attempt's world (completed-across-crash, + G-RULE-2), so the single-epoch expectation reds an honest history. + Closure (which keys) stays exact both directions. +- P-ADOPT (adopt legality, GS-CO-002): every adoption is justified + by a validated MATCH consult announced by the adopting + (node, generation) BEFORE the adopt commits — the checkable form + of R2-F3's MATCH-only eligibility. This monitor, not SealExpect, + is the `adoptOnFail` kill: FAIL-adopt laundering is + mechanism-visible only (see §6). +- P6-G (laundering oracle, all legs): unchanged from v2; round 2 + confirmed mechanism-independence (both kills flip against it). +- P6-E (mechanism conformance, E+B): retraction liveness — every + reader execution of a dead value re-runs before seal (keying per + §3; adopting re-readers included per R2-M5's pin). +- P6-S (mechanism conformance, S): AT-SEAL form only (round-2 R2-F6): + no sealed output carries a dead-generation stamp; no partition + mixes causally incomparable generations. P6-S red MEANS the + mechanism failed (a dead stamp survived the pass). The + VALUE-BLINDNESS pin is recast (R2-F6's vocabulary fix): + dead-stamp-forced redo on value-identical re-derivation is + intended MECHANISM BEHAVIOR whose signal is the FORCED-REDO COUNT + (derived announces: observation-pass re-runs, dead-read events, + retraction re-admissions) — a bake-off metric, never a property + verdict. A cell expecting mechanism overhead declares an expected + count, not a red. +- P-GEN: no two attempts contain store-commit announces attributed + to the same (node, generation); adoption re-announces attribute to + the adopter (R2-N3's rule, recorded). +- P-MARK (round-2 R2-F4): marker ⟹ partition equals the marked + round's outputs; announce-evidenced (markers, clears, adopts, and + row commits are all announced). +- Compression admissibility: unchanged (G9; safety verdicts + invariant, redo may grow). + +### 7.5. The frozen mechanism tally (amended v3, BEFORE any bake-off run — the round-2 findings changed mechanism counts and the tally must reflect them pre-run; further amendment requires a change order) + +| column | mechanisms | +|---|---| +| shared | frontier checkpoint (+ admitted-derivation set with DEATH SEMANTICS, admitted-by edges, cursors); forced resume checkpoint; generation table + bump rule + QUIESCE-BEFORE-BUMP; markers with premise digests + publishBearing + adopt-or-re-derive (MATCH-only, writer-ineligible) + marker lifecycle column; supersession matrix + poison rule; sweep + closure oracle; unit ops | +| E adds | durable admitted-by edges (checkpoint row); ∀-pending-purge (redo machinery); derived-support rebuild + agreement check; retraction rule + queue with pinned enqueue/drain; REQUIRES session variant B | +| S adds | stamp merge on read; stamp field + `eAdopt` rewrite; three observation points (dispatch-time refusal, session-read read-through + dead-read count, pre-seal pass with iteration budget); optional bucketed compression | + +Counting rule unchanged (durable state classes > scheduler rules > +per-output overhead). + +## 8. Small-scope configuration budgets + +As v2 (safety envelope; widened bake-off envelope: depth 2, one +fan-in edge), plus: PASS-ITERATION BUDGET (round-2 R2-M7): ≤ 3 +pre-seal pass iterations per seal; honest cells must converge within +it (checked — a budget-exhausted seal with dead stamps is P6-S red +and means a mechanism bug). ATTEMPT BUDGET ≤ 3 (unchanged). +INDUCTIVE-BET RESTATEMENT: the envelope excludes session-transitive +(reader-writer) chains, publish-derived demand, and SESSIONS × +DEMAND SHRINK (round-3 R3-M4: a de-demanded writer × a +still-demanded reader of its sync-scoped value — the one shape +where §4a's convergence mechanism has no lever) by declaration +(§1); first-order retraction and row-transitive support are +exercised (G6b/G6c); the bet is that no graph-runtime bug class +requires deeper session topology — stated, not assumed silently. + +## 9. Scenarios and cells (expected verdicts declared before first run) + +- **G1 phantom union**: legs (i) crash-before-commit → fetch-fresh, + GREEN (round-2 walked, derives); (ii) crash-after-commit + + mutation → marker found, revalidation FAILS → RE-DERIVE (MATCH-only + pin; NOT adoption) → fetch-fresh RECORD round — §4b's record + REPLACES row removes the dead rows AND deletes the marker (round-2 + text correction applied) → seal rows(e2)@V2, GREEN both variants; + (iii) crash-after-commit, no mutation → MATCH, digest equal, + writer bit clear → ADOPT → GREEN both variants (round-2: "the + repair working"). Mutant `suppressionOff`: P1-LEGALITY first-find + via the racing schedule (sequential adopts; live-fromGen deviation + noted). +- **G1b generation-reuse probe**: unchanged (round-2 verified + well-formed). `resumeCkptOff` → P-GEN RED. +- **G1c FAIL-adopt probe (round-2 R2-F3)**: e1→e2→e3, crash in the + announce window after attempt 1's CHANGED-WITH-DIFF unit (marker + digest = (V1, FAIL)); attempt 2's re-consult FAILS vs e3. Honest: + MATCH-only pin forces re-derive → fetch reflects e3 → GREEN. + Mutant `adoptOnFail`: adopts rows(e2) after the FAIL consult → + P-ADOPT RED (GS-CO-002; kill reassigned off SealExpect — the + sync-scoped expectation set accepts rows(e2) because e2 is a + legitimate attempt-start world of the sync, and the + completed-across-crash schedule seals it honestly; SealExpect and + P3′ are declared GREEN controls on the mutant cell). +- **G1d dead-in-flight probe (round-2 R2-F1)**: G2's E+B chassis, + schedule forcing the retraction bump while the dying reader + executes. Honest: quiesce defers the bump; the re-derivation is + the last writer; P6-G GREEN. Mutant `quiesceOff`: the dead unit's + late clear+commit wipes the live rows → P6-G RED. +- **G1e mid-bump reuse probe (round-3 R3-F2)**: the G-pending + chassis, two crashes; attempt 2's retraction-forced bump mints + (G, g3), G@g3 commits a durable unit, crash lands with the + elective checkpoint skipped. Honest: the §3 MID-BUMP FENCE forces + the checkpoint at the bump, so resume 2 restores a table already + carrying g3 and mints g4 — no collision; P-GEN GREEN; the reuse + history is unreachable-after-pin. Mutant `midBumpFenceOff`: resume + 2 re-mints (G, g3) from the stale table → attempts 2 and 3 both + carry (G, g3)-attributed store commits → P-GEN RED. +- **G2 session laundering**: legs as v2 with round-2 corrections: + E+A → P6-G RED (derives; round-2 walked). E+B → P6-G GREEN under + the quiesce pin (round-2: conditionally derivable, now + unconditional); `retractionOff` → P6-G RED. S+A and S+B → P6-G + GREEN, P6-S green (derives; the writer re-derives live and the + pass converges); `stampMergeOff` → P6-G RED. SAME-VALUE CONTROL + LEG (round-2 R2-F6 correction): H@g2 re-derives d1 exactly → + P6-G GREEN, P6-S GREEN at seal, FORCED-REDO COUNT ≥ 1 (declared + expected count, not a red — G's re-derivation is forced by the + writer-stamp delta). ANNOUNCE-WINDOW LEG (round-2 R2-F2's + placement, now scripted): checkpoint captures H pending with its + publish-bearing unit committed; crash; resume bumps H → H is + adoption-INELIGIBLE (publishBearing) → re-derives → re-publishes + → readers cleared (retraction under E+B / stamp delta under S) → + P6-G GREEN, P6-S green, pass converges within budget. CHASSIS + REGISTRATION (round-3 R3-F1): the `writerAdopt` kill needs an + adoption-ELIGIBLE publish-bearing marker, which under the §3 + body-op pin is constructible by script — a REPLAY-verdict + publish-bearing unit (MATCH consult, body publish) with a + premise-stable resume (no between-attempt mutation), so the + re-consult MATCHes and the digest is equal; the kill leg schedules + exactly this chassis. Mutant + `writerAdopt` on this leg: S → P6-S RED (stranded dead publish; + pass budget-exhausts — R2-F2's loop as a kill); E+B → P6-E RED (no + re-publish, no retraction). WRITER FLAP-BACK PROBE (round-3 + R3-F1's second registration): H's diff-verdict publish-bearing + unit commits; checkpoint in the announce window; crash; upstream + flaps back (content(e3) = content(e1)). Resume: H ineligible → + re-derives → re-consult MATCHes → REPLAY verdict → the body-op + pin re-publishes d1@g2 anyway → writer-stamp delta re-derives G → + pass converges. Expected: GREEN, forced-redo count ≥ 1 (under the + elision reading this history would strand d1@g1 and red P6-S + honestly — the probe is the body-op pin's load-bearing witness). + G-PENDING LEG (round-2 R2-M6(i)): + checkpoint captures G pending mid-read-window; G's pre-re-publish + re-run reads stale d1, then H re-publishes d2 → the re-retraction + clause fires (G re-runs again) → P6-G GREEN; witnesses the keying + pin's re-retraction clause. +- **G3 artifact swap**: unchanged, GREEN (round-1 walked clean). +- **G4 duplicate admission**: unchanged (suppression GREEN; + `suppressionOff` RED; distinct-derivation shape lives in G8c). +- **G5 sweep family**: (a)–(d) unchanged from v2 (round-1/round-2 + walked); (e) purge-domain cell under the ∀-purge pin — the + paginated parent's child C has ONE admitted-by edge (dead) → purged + → hash removed → count oracle asserts no post-resume C execution; + `purgeOff` → count-oracle RED. (f) `demandDropOff` → closure + oracle RED; HONEST BASELINE re-derived under the R2-F5 pins + (no-shrink epoch: C re-admitted after hash removal via the live + re-derivation — starvation unreachable; round-2's composition + defect repaired and the cell asserts it). +- **G6 redo-work bake-off**: scripts unchanged from v2 [GS-CO-005: + the v2 text is unrecoverable; the control legs are declared in + §12]; G6c's E leg + now derives under the ∀-purge pin (C survives on S2's live edge — + round-2's ∃/∀ divergence resolved); expected counts unchanged; + writers' forced re-derivations (writer-ineligibility) appear in + the counts wherever a session writer dies — declared expected, + charged to BOTH variants equally (the pin is shared machinery). +- **G7 progress under churn**: unchanged (generation-blind + fingerprint; ladder; budget 3). +- **G8 supersession family**: (a) record REPLACES over dead debris — + GREEN (clear wipes rows AND marker); (b) OVERLAY-intent dead base — + honest GREEN by scripted policy, `overlayComposeDead` RED; + (c) same-key distinct-derivation race — poison + SealExpect + exclusion + legality exemption + MARKER VOIDED (R2-M8; a scripted + forced re-run of the first node post-poison must NOT adopt — the + leg asserts re-derive-or-refuse on a poisoned key); (d) MARKER + FLAP-BACK PROBE (round-2 R2-F4): e1→e2→e3 with content(e3) = + content(e1), two crashes; attempt 2 re-derives via record REPLACES + (marker deleted); attempt 3's consult finds NO marker → ordinary + consult → V1 MATCHes vs e3 (truthful validator; content reverted) + → REPLAY verdict (round-3 R3-M1's correction: not fetch-fresh — + replay of the e1 base = rows(e3), SealExpect verdict-equal either + way) → SealExpect rows(e3) GREEN. Mutant `markerCleanupOff`: + the stale marker survives, attempt 3 premise-matches it (V1 MATCH + vs e3) and adopts content the marker no longer describes → P-MARK + RED (+ P3′ RED under E per the round-2 walk). +- **G9 compression admissibility**: unchanged from v2. + +## 10. Adequacy obligations + +1–6 as v2 (kills incl. count-oracle kills; reachability probes; +independent oracle bases; rebuild-agreement active in E resumes; +bake-off table from checker output + frozen tally; G5d meta-analysis +with a which-is-right determination). +7. The decision rule (§10.7, v2) unchanged [GS-CO-005: the v2 text + is unrecoverable; the rule as declared in §12 is the citable + version]; the §7.5 tally as amended + v3 is final for the bake-off (further amendment = change order + BEFORE any bake-off run). +8. NEW (round-2): P-MARK active in every cell with a marker; + convergence of the pre-seal pass within the §8 iteration budget is + asserted in every honest S cell (a budget-exhausted honest seal is + a finding, not noise). + +## 11. Adversarial review record + +Three rounds complete; the spec is FROZEN at v4. Round 1 (full): +REJECT, 11 majors — dispositioned in v2. Round 2 (targeted, +adoption): REJECT, 6 majors — adoption core verified sound; +seams dispositioned in v3. Round 3 (targeted, the v3 repairs; +`formal/reviews/graph-spec-round3-repairs.md`): REJECT, 2 majors + +4 minors + 3 notes — ALL six round-2 repairs verified soundly +applied and composing (writer-ineligibility convergence derives +mechanically on every scripted honest history; quiesce cannot starve +or deadlock; the marker matrix is total; admitted-set death +semantics close the starve/double-admission space; MATCH-only is +classifiable everywhere with SealExpect the right oracle; the G2 +table derives leg by leg), and every round-3 finding was +fix-without-re-review — per the review's own verdict, the fixed +spec needed a disposition registration check, not a fourth round. +v4 is that registration (§12). Checker verdicts against v4 are +citable. + +Standing questions (future change orders): MODEL_SPEC §10's list; +the elision-vocabulary boundary (§1 — if the runtime design elides +publish-bearing replay, re-open R3-F1's product); sessions × demand +shrink (§1/§8) if session scoping ever outlives a sync. + +## 12. Change-order log + +- v1: initial draft. Round-1 review: REJECT (11 majors + 7 minors + + 3 notes). +- v2: round-1 dispositions (see the v2 entry in the git history of + this file and `formal/reviews/graph-spec-round1.md`). Headline: + premise-validated adoption replacing marker suppression; + P6-G laundering oracle; generation-grounded fold pins; forced + resume checkpoint; durable admitted-by edges; total supersession + matrix; closure oracle; G5d meta-analysis reformulation; + divergence bake-off scripts + widened envelope; compression cells; + generation-blind P4 fingerprint; 10 minor/note registrations. + Round-2 targeted review of the adoption mechanism: REJECT (6 + majors + 8 minors + 3 notes; core verified sound, seams found). +- v3: round-2 dispositions + (`formal/reviews/graph-spec-round2-adoption.md`). R2-F1 → + QUIESCE-BEFORE-BUMP pin + retraction-queue semantics + G1d probe + + `quiesceOff` kill. R2-F2 (re-review target) → WRITER-ADOPTION + INELIGIBILITY: publish-bearing markers never adopt; dead publishes + are transient by construction and the pre-seal pass's convergence + is argued and checked (§4a, §8 iteration budget); `writerAdopt` + kill on the new announce-window leg; publish-derived demand + excluded from G-RULE-1 by declaration (§1). R2-F3 → MATCH-ONLY + adoption eligibility + ADOPT registered as a verdict class + G1c + probe + `adoptOnFail` kill + freshness prose corrected. R2-F4 → + marker lifecycle column in §4b (REPLACES clear deletes; unit put + overwrites; poison voids), P-MARK invariant monitor, §4a/G1(ii) + text corrections, G8d flap-back probe + `markerCleanupOff` kill, + per-sync marker scoping (R2-M3). R2-F5 → ∀-purge predicate; + purge/refusal remove the derivation hash; G-RULE-2 MUST-suppress; + G5f baseline and G6c E-leg re-derived. R2-F6 → P6-S at-seal form + only; forced-redo COUNT as the mechanism-overhead signal; G2 + same-value control leg corrected. Minors: session-read observation + registered as read-through + dead-read count with the + writer-pending invariant (R2-M1); derived-announce carrier pin + (R2-M2); marker scoping (R2-M3); dead-base detection wording + (R2-M4); adopting re-reads register normally (R2-M5); G-pending + re-retraction leg added, session-transitive chains and + publish-derived demand excluded with argument (R2-M6); + pass-iteration budget row (R2-M7); poison-voids-marker + G8c + post-poison leg (R2-M8). Notes recorded: eAdopt fromGen-dead + precondition (R2-N1), digest-closure vacuity sentence (R2-N2), + P-GEN monitor rule (R2-N3). Tally amended pre-run (§7.5). + Round-3 targeted review of the v3 repairs: REJECT (2 majors + + 4 minors + 3 notes; all six round-2 repairs verified sound; every + finding fix-without-re-review). +- v4 (FROZEN): round-3 dispositions + (`formal/reviews/graph-spec-round3-repairs.md`). R3-F1 → + SESSION-PUBLISH BODY-OP PIN (§3): session publishes are node-body + store ops executed by every non-adopted execution regardless of + verdict class (the reading round 2's accepted walks used, + registered); declared within-sync deviation from the walker's + elision vocabulary with the §1 F17 boundary sentence extended; + announce-window kill chassis registered (replay-verdict + publish-bearing unit, premise-stable resume); writer flap-back + probe leg added to G2 (expected GREEN, forced-redo ≥ 1). R3-F2 → + MID-BUMP FENCE (§3): a mid-attempt bump's generation-table delta + is durable (forced eCheckpoint) before the bumped generation + dispatches — the F4 discipline extended to the second minting + path; §5's two rows amended ("self-healing" scoped to the + scheduling effect, never the minted id); G1e reuse probe + + `midBumpFenceOff` kill (P-GEN RED). R3-M1 → G8d honest-leg + verdict corrected to REPLAY (SealExpect verdict-equal). R3-M2 → + store-side `eAdopt` poison precondition (closes the + check-then-act window). R3-M3 → pass ITERATION BOUNDARY pin (one + iteration = one scan over a drained frontier). R3-M4 → + convergence claim scoped to the scripted envelope; SESSIONS × + DEMAND SHRINK exclusion declared in §1 and §8's inductive bet. + Notes recorded: at-least-once cost claim verified honest (R3-N1, + into §4a); deferral non-starvation/non-deadlock arguments (R3-N2, + into §3); round-2 registrations sweep-verified applied (R3-N3). + FROZEN — subsequent changes are GS-CO-NNN change orders. +- GS-CO-001 (calibration, G1 build-out): G-RULE-3's durable fence + made TOTAL over all four minting paths (attempt-start root mint, + first-admission mid-attempt mint, resume bump, mid-attempt bump). + Found by P-GEN redding an HONEST single-crash G1 history: attempt + 1 crashed before any checkpoint, attempt 2 cold-restarted and + re-minted (P, 1). Encoding: path (a) rides `resumeCkptOff` + (making the G1b kill fireable with one crash — acceptable, the + kill statement is unchanged), path (b) rides `midBumpFenceOff`. + §2 amended in place, tagged. +- GS-CO-002 (calibration find G1-CAL-1): SealExpect content check + made sync-scoped (acceptable epoch SET accumulated across attempt + starts) — the single-epoch form reds the honest + completed-across-crash schedule, which G-RULE-2 licenses. The + `adoptOnFail` kill is consequently invisible to every + artifact-level oracle and moves to the new P-ADOPT mechanism + monitor (adoption requires a prior validated MATCH consult by the + adopting generation, announced before the adopt commits — the + announce-order pin is part of the monitor's soundness). §6, §7, + §9 amended in place, tagged. Calibrated: G1 sweep 10/10 at 5000 + schedules (greens hold incl. SealExpect+P3′ controls on the + mutant; kills red with first-finds P1-LEGALITY / P-GEN / + P-ADOPT). +- GS-CO-003 (calibration find, G2 build-out): CARRIER-DURABILITY + ATOMICITY. The R2-M2 carrier pin extends to durability: a + completion carrier's derived effects — every admission, mint, and + admitted-by edge — commit as ONE durable delta, and no checkpoint + may separate the carrier's completion from its admissions. The + per-mint fencing GS-CO-001 first encoded leaves a lost-demand + window: a crash between two children's fences restores the parent + COMPLETED with the second child's admission gone; a completed + parent never re-derives, the demand starves, and the closure + oracle reds an honest session-topology history (found on the + first honest G2 run). Edge-only registrations are covered too: a + lost live admitted-by edge mis-arms the ∀-purge predicate + (R2-F5) on resume. Encoding: one forced checkpoint at the end of + the carrier's demand loop, riding `midBumpFenceOff`. §2's + GS-CO-001 sentence is superseded on the (b) path by this rule. +- GS-CO-004 (calibration find, G2 build-out): RETRACTION CATCH-UP + BOUND. The retraction rule is RE-PUBLISH-DRIVEN (R2-M6(i)'s + wording holds as written); the registration side (a read that + registers when its value's death is already knowable, i.e. the + read-note lost the race to the re-publish carrier) is a CATCH-UP + retraction spent ONCE per (reader, dead writer-generation). An + unbounded registration-side rule livelocks the `writerAdopt` + strand — the adopted writer never re-publishes, the reader + re-runs forever, the frontier never drains, and the at-seal + oracles (P6-E/P6-S) are structurally unevaluable, turning the + kill cell GREEN-by-divergence (found: the kill would not fire). + With the bound, the strand costs one re-run, seals, and P6-E + reds the still-dead final read. Session reads register at READ + time (read-through, R2-M1) via a scheduler note; carrier-time + registration makes the R2-F1 dying-reader race structurally + unreachable (also found in this build-out). +- GS-CO-005 (bake-off phase): BAKE-OFF PROTOCOL REGISTRATION — + provenance repair plus pre-run declarations. + (a) REPAIR: §10.6's meta-analysis, §10.7's decision rule, and §9 + G6's "scripts unchanged from v2" cite v2 subsection text + recoverable only from this file's git history, which was never + created (the formal tree is untracked as of this registration). + The rule and both deferred procedures are DECLARED here, BEFORE + any bake-off run; this text is the citable version and supersedes + the §9/§10 references. + (b) DECISION RULE (§10.7 restated): lexicographic, first non-tie + decides. Axis 1 — property satisfaction on the frozen 66-cell + matrix: an honest-cell red or an unfired declared kill eliminates + a variant; a correctness dependency (E REQUIRES session variant + B, evidenced by tcG2ea_P6G) travels with the variant as part of + its Axis-2 mechanism bill, not as an elimination. Axis 2 — + mechanism count per the §7.5 frozen tally under its counting rule + (durable state classes > scheduler rules > per-output overhead). + Axis 3 — redo work under the divergence scripts: minimal green + exec bounds per chassis, the declared-expected redo probes, and + pass-budget consumption. A hybrid recommendation is admissible + only if expressible as the shared column plus exactly ONE + variant's adds. + (c) G6 v1 CONTROLS (metric floor, declared): no-crash G6a/G6c + chassis at bound 1 — tcG6aE_Ctl / tcG6aS_Ctl / tcG6cE_Ctl / + tcG6cS_Ctl declared GREEN (zero-crash redo is zero under BOTH + variants; a red is a variant-overhead find, Axis-3 data). G6b + bound-1 probes — tcG6bE_Redo / tcG6bS_Redo declared RED (the + mutation chassis's redo exists under both variants; a green leg + is a divergence datum). + (d) G5d META-ANALYSIS (reachable-seal-world comparison, + declared): GSEALWORLD existence probe — RED means the announced + target world is sealed for the interrupted sync, where a world is + the manifest restricted to keys sealing non-empty partitions. On + the shrink chassis (cell 24, honest config), both variants: + W1 = {0→2} REACHABLE (RED probe: P re-ran at e2, C swept); + W2 = {0→1, 1→1} REACHABLE (RED probe: P completed-across-crash + at e1, C live — G-RULE-2); W3 = {0→2, 1→1} UNREACHABLE (GREEN + probe: the sweep-failure world; honest reachability would be a + P5-shaped finding). The W1/W2 REDs on the same chassis are the + probe mechanism's positive controls against a vacuous W3 GREEN. + WHICH-IS-RIGHT RULE: every reachable world must lie inside the + sync-scoped SealExpect envelope (asserted in-cell by the honest + G5a greens); a world reachable under exactly ONE variant is a + divergence finding that blocks Axis-3 citation until + dispositioned. diff --git a/formal/MODEL_SPEC.md b/formal/MODEL_SPEC.md new file mode 100644 index 000000000..94ff96b89 --- /dev/null +++ b/formal/MODEL_SPEC.md @@ -0,0 +1,1580 @@ +# Model spec — walker + source-cache replay calibration model (P) + +Status: v11, FROZEN. The v10 addendum (overlay-flavor extension of +the atomic-unit variant: §9.6 V-OVERLAY-UNIT, cells 6-overlay and +6-overlay-naive, §5 buffer row) received the targeted round-7 spot +review: REJECT with 3 majors + 2 minors + 2 notes, ALL +fix-without-re-review, applied as v11 +(`formal/reviews/model-spec-round7-overlay.md`); no cell verdict +overturned, no round 8 warranted. v11 also bundles the deliverable-2 +de-scope edits (the `compositionEnum` and `annotationBinding` toggles +stay documented but are NOT BUILT in P — the atomic unit is the +single fix story for the scoping bug family; §10.5 kill obligations +adjusted) and the case-3 re-run extension of V-ATOMIC (§9.6). All +prior content is reviewed through round 6. +The v8 addendum (§9 scenario 7 — sessions × replay elision, P6-R, +session-taint toggles) received the targeted round-6 spot review: +REJECT with 4 majors + 5 minors + 3 notes, ALL fix-without-re-review, +applied as v9 (`formal/reviews/model-spec-round6-scenario7.md`); all +cell verdicts and shipped-system claims verified, no round 7 +warranted. The v6 addenda (§9 cells 1d and 6, §7 fold-totality +clauses) passed the round-5 spot review similarly (2 majors + 6 +minors → v7, `formal/reviews/model-spec-round5-addenda.md`). Review history: round 1 REJECT (15 +findings → `formal/reviews/model-spec-round1.md`); round 2 of v2 REJECT +(2 blockers, both scenario-reachability defects → §9 re-scripted on the +graceful-stop premise generator, standing reachability-walk obligation +in §10.0 — `formal/reviews/model-spec-round2.md`); round 3 of v3 REJECT +(1 blocker: scenario 5b scripted a loud failure where the B1 contract +and code silently ignore annotations; all 18 §9 cells walked, 17 +confirmed — `formal/reviews/model-spec-round3.md`); round 4 of v4 +REJECT with 0 blockers / 0 majors — all seven round-3 dispositions +verified genuine, three fix-without-re-review minors applied as v5, +and per the round-4 verdict no further full round is warranted +(`formal/reviews/model-spec-round4.md`). On signoff this spec freezes +and is committed as the diffable baseline; deviations discovered while +writing P code are appended as change orders (MS-CO-NNN), never +silently absorbed. No green checker run is trusted before the freeze. + +Covers deliverables 2 and 3 of `docs/tasks/sync-formal-model-brief.md`: +the tiered walker + 6b source-cache replay orchestration, its calibration +cases, and the staged composition-enum mitigation. The graph-runtime +model (deliverable 4) gets its own spec addendum, with its own +adversarial review; the machine interfaces below are designed so the +graph scheduler variant slots in without remodeling +Upstream/Store/SessionStore. + +Vocabulary is `formal/GLOSSARY.md`. Behavioral ground truth is +`docs/verification/sync-replay-6b/plan.md` (frozen contract B1–B10, +CO-6b-001..007); code anchors are cited where the contract is silent. + +## 1. What is modeled, what is abstracted + +In the model: + +- The dispatch loop: LIFO action stack, batched same-op dispatch to + bounded workers, loop-top checkpointing, restart-from-root under hard + crash (CO-6b-002), graceful-stop forced checkpoints + (`checkpointOnStop`, run-expiry — `parallel_syncer.go` 195, 204, + 453–493; pre-seal forced site `syncer.go` 1162, Init sites 232/268). +- Source-cache orchestration: warm/cold install, hit recording, the warm + gate, hit-validator binding, once-per-scope replay dedup, per-scope + locks, page-op ordering (copy → upserts → tombstones → publish), + poison, replay-blocked marking at its real durability. +- Multi-sync chains (up to 3 syncs): a sealed artifact becomes the next + sync's previous artifact; gates G4/G7 modeled; G6 (capability) is a + PER-ATTEMPT bit (CO-6b-003's withdrawal-across-attempts case needs + it); G1/G2/G5 collapsed to one "previous artifact usable" boolean. +- Per-attempt compat config k ∈ {K1, K2} (what G7 byte-compares and B4 + cross-attempt-compares); rows carry a ghost config tag (§7 P1c). +- Two interruption modes: hard crash (volatile state lost, last durable + checkpoint wins) and graceful stop (batch aborts, forced checkpoint of + live state — including mid-chain cursors, admitted-but-undrained + spawns, and hits recorded during the aborted batch — attempt ends). +- Upstream mutation between attempts (always available) and mid-attempt + (per scenario); previous-artifact swap between attempts (case 3). +- The session store as shipped (variant A: free-form sync-scoped KV, + durable across attempts). Modeled surface: Get/Set only; the shipped + service also has Delete/DeleteMany/Clear — mutating ops the taint + toggles must cover in production (§6) but the model cannot reach. + +Abstracted away (soundness arguments in §8): + +- Storage internals: Pebble, batching, index synthesis, bytes. The store + is "partitions with atomic page commits and a manifest of scope → + validator entries". Batched clear/copy is abstracted to two atomic + steps; sub-batch partial-commit crash convergence was closed at the + store level in Phase 6a and is registered here as an exclusion. +- Row kinds: one STORAGE row kind (every calibration mechanism is + scope-level). Scenario 7 introduces a declared KIND axis on top: a + kind is an (action op, scope) pair — W and R are distinct ops over + distinct scopes, which is what gives sequential phases under §3's + same-op batching; the storage row-kind axis is unchanged (the + glossary's scope stays (row_kind, scope_key)), and per-kind + produce/consume state (session taint, §6) is scoped by this axis. + Scenario 7 is the only two-kind scenario. +- The G1/G2/G5 decision table (R2 chaos coverage, not scheduling + semantics). +- Grant expansion, external resources, targeted sync, static + entitlements, lookup ask/answer continuation, subprocess transports, + the compactor. +- Produce-side block triggers beyond §3's two: page-arrival shape + guards (child-resource declarations, `InsertResourceGrants`), + ingest-filter drops (B6), unknown-prior-checkpoint conservatism — + unreachable in the model (no child resources, no filter drops, every + modeled token carries the ingest-quality snapshot). +- Connector cross-call memory: scenario policies are pure functions + (§3 MWorker); the proto permits within-sync connector memory, and this + under-approximation is a recorded boundary (§8), not a claim about + connectors. +- Real pagination breadth: at most 2 pages per scope per round. + +Small-scope configuration (every known bug fits; the inductive bet is +stated in the brief's Honest limits): + +| dimension | bound | +|---|---| +| scopes | 1–2 | +| upstream epochs per scope | ≤ 3 | +| row identities per scope | ≤ 2 | +| syncs per scenario | ≤ 3 | +| attempts per sync | ≤ 3 (crash budget ≤ 2, stop budget ≤ 1) | +| workers | 2 | +| session keys | ≤ 1 | +| pages per scope per round | ≤ 2 | +| compat configs | ≤ 2 | +| kinds (action ops) per scenario | 1 (2 in scenario 7 only) | +| batch cap | nondet ∈ {1..2} per dispatch | + +Batch-cap scaling argument: reality's cap is 100 +(`maxPeekActionsCount`). The model's per-dispatch nondet cap {1..2} +explores the split shapes relevant at the model's action counts; +partitions into ≥ 3 batches are unexplored per split, but batch width +beyond the cap is independently reachable because same-op spawns are +admitted to the live batch uncapped, and multi-way splits decompose into +successive two-way splits at loop tops. CO-6b-006's 102-action two-batch +construction shows cap-induced splits are a real premise generator; a +model trace corresponds to a real scenario by inflating action counts, +never by changing the mechanism. + +## 2. Ground rules the encoding must obey + +Properties of the ENCODING (not the system) that the adversarial review +checks: + +1. **Genuine choice points.** Worker interleaving at atomic-step + granularity, crash/stop placement, checkpoint-or-skip at loop tops, + upstream mutation timing, batch cap per dispatch, and store-op + arrival order across senders are all resolved by checker-explored + nondeterminism — never fixed by encoding order. +2. **Crash wipes volatile state and only volatile state.** §5's table is + mechanically enforced: attempt-owned machines die at crash; the Store + survives with exactly its committed state; resume constructs a fresh + MSyncAttempt from the checkpoint token alone. +3. **Mitigations are guards, not behavior.** Every §6 toggle disables a + check/lock that exists in the shipped design; toggles never add + transitions. +4. **Monitors observe, never steer.** Spec machines subscribe to + announce events; ghost state only. Ghost labels attached to events + (§7) must be honest labels of decisions the model already made for + behavioral reasons, never scenario foreknowledge. +5. **One semantics, one place.** Connector policy, page-op ordering, and + gate logic are each encoded once and parameterized per scenario. +6. **Premises must be walked, not asserted.** Every §9 scenario premise + must be mechanically reachable under §3's semantics; the reachability + walk is part of the spec (§9 states each route) and of the review + charge (§10.0). + +## 3. Machines + +### MEnv (test driver, per scenario) + +Owns the scenario configuration (toggles, policy table, crash/stop +budgets, chain length, swap schedule, per-attempt capability bit and +compat config schedule). Runs the sync chain: + +- start attempt → await one of {seal, crash quiesce, stop quiesce, + attempt failure}; +- on crash/stop quiesce: start the resume attempt; +- on ATTEMPT FAILURE (a loud cold verdict — §4): resume-on-failure up to + the attempt budget; with `abandonLadder` on, after k identical + failures abandon the sync and start the next sync cold (6c ladder); + with it off, budget exhaustion with the P4 livelock rule (§7) firing + is the recorded outcome; +- on seal: roll the artifact (it becomes the previous artifact) and + start the next sync; perform the scheduled artifact swap, upstream + mutation, capability withdrawal, or compat-config change between + attempts when the scenario declares one. + +### MUpstream + +Per scope: epoch counter `ep[s]`, content function `rows(s, e)` (fixed +small table per scenario), validator `V(s, e)` truthful by construction +(`V(s,e1) == V(s,e2) ⟺ rows(s,e1) == rows(s,e2)`). Serves +`eValidate(s, v)` (match against current epoch) and `eFetch(s)` (rows, +validator, ghost epoch). `eMutate(s)` from MEnv; mid-attempt mutation +only when the scenario enables it. + +### MSyncAttempt (walker scheduler, one per attempt) + +Volatile state, initialized from the checkpoint token: action stack +(op, page token, scope binding, spawned flag), hit map (scope → +validator), replayed set, ingest-quality snapshot (incl. replay-blocked +reason flags), warm flag — NEVER from the token; recomputed per attempt +(B1, CO-6b-003; `sourceCacheWarm` is a syncer field, +`source_cache_orchestration.go` 363). + +Warm install at attempt start (`installSourceCacheLookup`): usable-prev ∧ +this attempt's G6 capability bit ∧ G4(prev not replay-blocked) ∧ +G7(compat byte-match: this attempt's config vs prev artifact's compat +record) ∧ no drift this attempt → warm; else cold. Produce-side +blocking — exactly two triggers WITHIN THE MODELED FRAGMENT: + +1. compat config recomputed differently across attempts of this sync + (B4); +2. this attempt runs without source-cache handling (G6 bit off) over a + store carrying prior-attempt produce state (CO-6b-003 + capability/shape withdrawal), fail-closed on compat-read error. + +The system has further block triggers the model cannot reach and +excludes (§1): page-arrival shape guards (child-resource declarations, +`InsertResourceGrants` — `ingestQualityReasonSourceCacheShapeUnsupported`), +ingest-filter drops (B6), and unknown-prior-checkpoint conservatism on +restore. "Two triggers" is a claim about the modeled fragment, not the +walker. + +Consume-side degradation alone (previous artifact withdrawn, blocked, or +mismatched) NEVER blocks the current artifact (R13: routine resumes must +not become chain breaks). + +Dispatch loop (mirrors `parallelSync`): + +1. Loop top: stack empty → seal sequence → report seal. +2. Checkpoint decision: nondet {checkpoint, skip}, with forced + checkpoints after Init and before seal (`syncer.go` 1162), and the + graceful-stop forced checkpoint below. `eCheckpoint` snapshots + (stack, hit map, replayed set, ingest-quality) — §5. +3. Batch: take the consecutive same-op prefix of the stack top, bounded + by this iteration's nondet cap; dispatch to free MWorkers; await + batch end (all dispatched actions finished or batch aborted). +4. Batch bookkeeping (mirrors the queue contract, `parallel_syncer.go` + 608–716): same-op spawns are committed to LIVE scheduler state + first, then admitted to the live batch queue and drained within the + batch (`outstanding` gates batch end) — so a loop-top checkpoint can + never contain an unfinished same-op spawn; cross-op spawns are + pushed to the stack. Spawn admission is deduplicated by identity + digest for ALL spawns, same-op included (`transitionAction`'s + spawnedAdmitted guard — re-mentions of finished work are legal + connector behavior and are skipped, not errors), plus a commit-local + duplicate-cursor rejection within one transition (loud failure; + SAME-OP children only — cross-op children bypass it in code); the + dedup index is volatile and rebuilt from the checkpointed stack on + resume. Completed actions pop AT COMPLETION — the pop is a + live-state transition committed mid-batch, not batch-end + bookkeeping (the 2-stop cell depends on a stop checkpoint capturing + one action popped and its batchmate mid-chain). An aborted batch + leaves its unfinished actions on the stack — a + dispatched-but-unfinished action's stack entry retains the token of + its LAST COMMITTED transition (mid-chain), because + `transitionAction` writes page advances into live state as they + commit; admitted-but-undrained spawns likewise remain in live state. + +Graceful stop (`eStop`): the in-flight batch aborts (workers stop at the +next atomic-step boundary; the failing/stopped actions stay unfinished); +MSyncAttempt force-checkpoints the LIVE state — including hits recorded +during the aborted batch, admitted-but-undrained spawns, and mid-chain +cursors of unfinished actions — then the attempt ends +(`checkpointOnStop`, run-expiry force; spawn checkpointability is pinned +by `TestSpawnedActionsSurviveCheckpoint`). This is the one path by which +mid-batch state becomes durable; hard crash never checkpoints. The stop +path is therefore the model's premise generator for "stranded carrier + +recorded hit" states (§9). + +### MWorker (×2) + +Owns one action at a time and runs its ENTIRE page chain to completion +within the batch (mirrors `syncOneAction`): per page — connector call, +page ops, then either continue with the next page token (committing the +advance to live state via the transition, staying inside the same +worker) or finish (the pop commits at completion, mid-batch). A +loop-top checkpoint can +therefore only ever contain root tokens for never-dispatched actions; +mid-chain tokens reach durability only via the stop path. + +Connector call (synchronous request/response): consult = `eLookup` on +the Store's previous-artifact surface, then on hit `eValidate` against +upstream. HIT RECORDING IS PINNED: the hit and its validator are +recorded into the volatile hit map at LOOKUP-HIT time, before and +regardless of the revalidation outcome +(`previousSyncSourceCacheLookup.LookupPreviousSourceCache` fires `onHit` +at lookup time, `source_cache_orchestration.go` 211–214); a later hit +for the same scope OVERWRITES (last-write-wins, +`state.RecordSourceCacheHit`). + +Verdict per the scenario policy table — a pure function of (action, +page position, lookup result, upstream response, session reads). This +purity is a modeling simplification, not a connector contract (§8): + +- unchanged → replay page(s); the annotation carries a validator or not + per scenario cell (both shapes are legal per proto); +- changed-with-diff → replay + overlay record pages; +- changed / miss → fetch → record pages under the new validator; +- planning shape: consult k scopes, spawn same-op carriers via + `EnqueuePageTokens` with (scope, verdict) baked into their page + tokens — the token is the verdict channel across attempts; policies + may also consult on later pages of the same chain. + +Session ops (`eSessionGet/Set`) happen inside page handling when the +policy says so. + +### MStore (durable; one per scenario, holds the whole chain) + +Durable state per sync: partitions (scope → set of (row id, ghost +provenance)), manifest (scope → validator [+ sealed count]), poison set, +replay-blocked flag (via checkpointed ingest quality — see §5), compat +record, session KV, checkpoint token, sealed flag. Plus the +previous-artifact binding, rebindable by MEnv between attempts (case 3). + +Atomic ops (one event each, processed to completion; announce on +commit): `eCheckpoint(token)`, `eLookup(s)` (miss when poisoned/absent, +or when the scope's kind is session-tainted in the previous artifact's +produce state — degradation, never a loud verdict; §6), +`eGateRead`, `eClearScope(s)` (acting-scope semantics: never poisons the +scope being replayed), `eCopyScope(s)` (preflight: entry present ∧ not +poisoned; count consistency is a 6a store guarantee out of scope; ghost +provenance: replay lineage fields (V_base, epoch_base, config_base) are +ADDED to copied rows, and embedded session stamps, when present, are +copied UNCHANGED — the single semantics P6-R's stamp travel refers to), +`eUpsertPage(s, rows)` (a put whose row identity is stamped with a +different scope poisons the losing scope; out-of-scope delete/overwrite +poisons likewise), `eTombstones(s, ids)`, `ePublishEntry(s, v)`, +`eSessionGet/Set`, `eSeal`. SCENARIO-LOCAL ops (§9.6 design variants +only; registered here per MS-CO-001 so §5's crash protocol and §2.1's +arrival-order choice points quantify over the full op vocabulary): +`eReplayUnit(s, v)` (V-ATOMIC's one-op {clear, copy, marker, publish}), +`eOverlayUnit(s, v, pages)` (V-OVERLAY-UNIT's one-op unit), and the +marker ops `eMarkerPut(s)` / marker read (the per-scope marker row all +§9.6 variants share). + +Scheduler-state mutations (hit recording, replayed marking, warm flag, +stack transitions, ingest-quality/replay-blocked flags) are NOT store +ops; they reach durability only inside `eCheckpoint` (CO-6b-006 +semantics: state recorded in the batch that crashes is lost with it). + +### MCrashInjector + +Emits `eCrash` (hard) or `eStop` (graceful) between any two atomic +steps, within the scenario budgets. Crash delivery races in-flight store +ops per §5's prefix rule. + +## 4. Page-op sequence (the replay/record hot path) + +For one scoped page, each named check a separate atomic step. +(Scenario 6's design variants — §9.6 — REPLACE this sequence for +unit-mode scopes: the variant declarations there are the authority; +MS-CO-001.) + +``` +acquire scope lock (s) [toggle: scopeLocks] — record pages too (CO-6b-006) +if replay page: + warm-gate check [toggle: warmGate] + hit check: s ∈ hit map (B5 provenance; loud cold on absence) + [toggle: annotationBinding] annotation validator, when present, == hit validator (case-3 fix, PROPOSED) + if s ∉ replayed set: [toggle: oncePerScope] + base-binding check: current base manifest[s] == hit validator [toggle: hitValidatorBinding] + eClearScope(s) (atomic) + eCopyScope(s) (atomic) + mark replayed (atomic, volatile scheduler state) +eUpsertPage(s, page rows) (atomic) +eTombstones(s, ids) (atomic, when present) +ePublishEntry(s, v) (when the page carries a validator) +release scope lock +``` + +Failure semantics: + +- A COLD verdict (gate/provenance/binding failure) fails the ATTEMPT + loudly; MEnv's resume-on-failure rule applies. Because the offending + cursor is checkpointed, the failure recurs deterministically — the P4 + livelock shape — until `abandonLadder` (when on) abandons the sync. +- A WARM page failure (destination write error) is modeled ONLY in the + lock scenario that needs it: the page fails after `beforeUpserts` + acquired the lock; the WORKER retries the action in-attempt (mirrors + `syncOneAction`'s retry loop), which re-enters the page sequence and + re-acquires the scope lock. With the model's release-on-error edge + removed (mutation check), the retry deadlocks — the CO-6b-007 hang. +- A replay-annotated page arriving in an attempt WITHOUT source-cache + handling (G6 bit off) is SILENTLY IGNORED — no-op page ops, no + failure (B1: absent capability means every source-cache annotation is + ignored for the whole sync; `sourceCachePageOps` returns nil ops when + `sourceCacheEnabled()` is false, `source_cache_orchestration.go` + 463–468). Produce-side blocking trigger 2 fires at ATTEMPT START + (install time) over prior-attempt produce state, fail-closed only on + compat-READ error — never at page arrival. + +Deliverable 3 (staged composition enum) — INPUT ASSUMPTION to confirm +against the PR discussion, at its REAL durability: record pages carry a +wire intent {OVERLAY, REPLACES} (the word "intent" is reserved for this +wire enum; the P1 ghost label is called "verdict class" and exists +regardless of this toggle). Detection is SYNCER-SIDE: when an attempt +observes, in its own (volatile + checkpoint-restored) state, both a +completed replay copy and a REPLACES-intent record for one scope in one +sync, it sets the replay-blocked reason flag — which reaches durability +only at the next checkpoint/seal, like the rest of ingest quality. The +model must therefore exhibit BOTH weaknesses as findings, not +surprises: (a) crash between detection and checkpoint loses the block; +(b) the carrier-less phantom (§9 case 1c) leaves no syncer-visible +evidence a copy ran, so detection never fires. The deliverable-3 claim +("propagation bounded to the one corrupted artifact") is verified ONLY +for the shapes where detection is reachable, and the calibration report +must state that boundary; an op-commit-durable store-side variant may be +modeled ADDITIONALLY for comparison, clearly labeled as stronger than +the proposal. + +## 5. Durability, crash, and resume semantics + +| state | owner | durability | +|---|---|---| +| partitions, manifest, poison, compat, session KV, sealed flags | MStore | durable at op commit | +| checkpoint token: action stack (incl. admitted spawns and, on the stop path, mid-chain cursors), hit map, replayed set, ingest-quality snapshot (incl. replay-blocked reason flags and session-taint marks) | MStore | durable at eCheckpoint commit | +| live stack, hit map, replayed set, ingest-quality/replay-blocked flags, session-taint marks | MSyncAttempt | volatile (checkpoint-cadence durability) | +| warm flag | MSyncAttempt | volatile AND never checkpointed (recomputed per attempt) | +| scope locks, in-flight batch, worker page position | MSyncAttempt/MWorker | volatile | +| spawn-dedup index | MSyncAttempt | volatile; rebuilt from the checkpointed stack on resume | +| overlay collect buffer (V-OVERLAY-UNIT, §9.6 only) | MWorker | volatile; never checkpointed — harmless to lose: page transitions defer to unit commit (§9.6 o-i, round-7 F1), so the stop checkpoint holds the consult-page token and a marker-less resume re-enters at consult | +| replay/overlay unit marker (§9.6 variants only) | MStore | durable at op commit (per-scope store row; rides INSIDE the unit for V-ATOMIC/V-OVERLAY-UNIT, trails as its own op for V-NAIVE/V-OVERLAY-LAST — the placement IS the bake-off variable); MS-CO-001 | +| upstream epochs | MUpstream | environment (unaffected by crash) | + +Crash protocol (pinned): `eCrash` is enqueued to MStore like any op; its +POSITION in MStore's queue partitions the dead attempt's outstanding +ops — ops the store processed before the crash event are committed; ops +behind it are DROPPED, never processed. Per-sender FIFO delivery holds, +so each worker's committed ops are a prefix of its issue order (the WAL +property); interleaving ACROSS senders remains a genuine choice point. +MEnv starts the resume only after quiesce: every attempt-owned machine +halted and the store's queue contains no dead-attempt ops (dropped, not +processed). No dead attempt's op can commit after the resume attempt +starts. + +Resume: fresh MSyncAttempt from the MOST RECENT durable checkpoint, +alone. In crash-only histories that checkpoint is a loop-top/forced +one containing only root tokens (§3 MWorker) — restart-from-root +(CO-6b-002) is the structural consequence for those histories. +Restart-from-root is a property of WHICH checkpoint survives, not of +the crash itself: a stop-forced checkpoint that survives a LATER hard +crash legally carries mid-chain cursors and admitted spawns, and +resume restores them as-is. Under graceful stop the forced checkpoint +may contain mid-chain cursors and admitted-but-undrained spawns; +whether a +replay annotation can be resumed mid-chain WITHOUT a fresh consult is +deliberately left reachable and checked as conformance question C1 (§9) +with a concrete probe script — CO-6b-002 calls that shape "unreachable +in practice", and the model either confirms that or produces the trace +that refutes it. Either outcome is recorded. + +## 6. Mitigation toggles + +OFF never adds behavior; it removes a check or a lock. + +| toggle | guard | contract | default (shipped) | +|---|---|---|---| +| `warmGate` | replay requires this attempt's warm flag | CO-6b-003 | on | +| `hitValidatorBinding` | copy requires base manifest[s] == recorded hit validator | CO-6b-004 | on | +| `scopeLocks` | per-scope mutex incl. record pages, held across the page, released on every path | CO-6b-003/005/006/007 | on | +| `oncePerScope` | replayed-set dedup of the replacement copy | B5 | on | +| `annotationBinding` | replay annotation's validator (when present) must equal the recorded hit | case-3 fix, PROPOSED — DE-SCOPED v11: not built in P, no kill obligation; V-ATOMIC subsumes it (§9.6 case-3 re-run) | off | +| `compositionEnum` | syncer-side REPLACES+replay detection → replay-blocked flag (checkpoint-durable) | deliverable 3, PROPOSED — DE-SCOPED v11: not built in P, no kill obligation; the atomic unit is the single fix story for the scoping family | off | +| `abandonLadder` | after k identical resume failures, abandon and start the next sync cold | 6c ladder | off | +| `sessionTaintWrites` | produce-side: a connector session WRITE during a replay-capable kind's phase marks that kind non-replayable in this artifact's produce state (checkpoint-durable, ingest-quality-style) | sessions×replay fix, PROPOSED (partial) | off | +| `sessionTaintAll` | produce-side: ANY connector session traffic (read or write) during a replay-capable kind's phase marks that kind non-replayable (checkpoint-durable, ingest-quality-style) | sessions×replay fix, PROPOSED (isolation) | off | + +Taint pins (round-6): REPLAY-CAPABLE KIND = a kind in the declared +source-cache flow — its rows are eligible to seed future replays from +this artifact — INDEPENDENT of the recording attempt's warm/cold state +(the taint records in cold attempts too; scenario 7's sync N is cold by +construction and the 7a fix run depends on it). WRITE = any mutating +session op (Set/SetMany/Delete/DeleteMany/Clear; the model reaches Set +only, §1). Durability is checkpoint-cadence (§5) and SELF-HEALING under +at-least-once re-execution: any checkpoint capturing the writer's pop +captures the taint in the same snapshot, and a crash losing the taint +also loses the pop, so the re-run re-records it — a stronger story than +`compositionEnum`'s detection evidence, claimed explicitly. Consume +side: a tainted kind's scopes read as lookup MISSES (degradation, never +a loud verdict — §3 `eLookup`). A capability-level OPT-OUT (the +connector attests emission-irrelevance: "my session traffic during +replay-capable listings does not influence emitted rows") disables the +taint detector for those kinds; it is trust-boundary machinery like the +truthful-validator assumption and needs no new cells — a dishonest +opt-out reproduces 7a/7b exactly, an honest one is green by definition +of emission-irrelevance. + +Kill obligations (§10.5): every BUILT toggle has at least one §9 cell +whose verdict it flips — `warmGate` in 5a, `hitValidatorBinding` in 3B, +`scopeLocks` in 4, `oncePerScope` in 4, `abandonLadder` in the P4 +cells, `sessionTaintWrites` in 7a (its 7b residual is a REQUIRED +finding), `sessionTaintAll` in 7a and 7b. The DE-SCOPED toggles +(`annotationBinding`, `compositionEnum` — v11) carry no kill +obligation: they remain documented as reviewed design records, their +fix duty discharged by the atomic-unit story (§9.6's 1a/1b/1c and +case-3 re-runs under V-ATOMIC). + +## 7. Properties (checkable forms) + +Announce events double as the deliverable-6/7 trace vocabulary: +`consult(s, hit?, v, validated?)`, `replay(s, v_base, e_base, k_base)`, +`record(s, v, e, k, wire_intent?)`, `upsert(s)`, `tombstone(s)`, +`publish(s, v)`, `checkpoint`, `stop`, `seal(n)`, `crash(k)`, +`session_read/write(k, stamp)`, `blocked(reason)`. Ghost fields (epochs, +verdict classes, configs, stamps) are labels of decisions the model +already made for behavioral reasons (the policy verdict, the upstream +response, the attempt's config) — §2.4. + +- **P1 — binding integrity (safety).** Per (sync, scope) the monitor + folds the ROUND LOG. A ROUND is the maximal run of pages of one + action chain for one scope under one verdict; its ghost label is + (verdict class, consult epoch, attempt config); a round is TORN if + its pages committed in more than one attempt; only COMPLETE rounds + enter the fold (torn or INCOMPLETE rounds' debris surfaces as + content divergence, which is the intended alarm — 6-naive's verdict + rests on the incomplete class). Log legality rules: at most + one replacement copy per scope per sync; an overlay round composes + only onto this sync's completed replay of the base its verdict was + computed against. Deterministic fold over complete rounds, ordered by + ROUND COMPLETION — the commit of a round's last page. A page COMMITS + when the last of its prescribed STORE ops commits (announce-visible); + action transitions and pops are scheduler events, NOT fold events; a + round that commits no store ops contributes no fold entry (round-5 + F1 pin — the only reading the §2.4 announce-subscribed monitors can + implement). Rounds enter + the fold when they complete, so completion order IS the fold order; + pages of different rounds may interleave in commit order without + affecting it (pinned so out-of-script counterexample logs fold + identically for every implementer): replacement → rows(s, e_base); overlay(e_from → e_to) — + requires current fold value = rows(s, e_from), yields rows(s, e_to); + a COPY-SKIPPED duplicate overlay round (B5 legal: the replacement + copy is skipped for an already-replayed scope and the page's + upserts/tombstones apply normally) folds as a NO-OP when the fold + value already equals rows(s, e_to); an overlay round whose OWN + replacement copy committed is SELF-GROUNDING — folds as rows(s, + e_to) regardless of prior fold value, its copy counting toward + replacement legality (case 4's locks-on surviving round is this + shape); a COPY-SKIPPED REPLACEMENT round commits no rows and folds + as a NO-OP — its publish, when validator-bearing, participates in + the attestation checks only (1d's stale carrier); anything else is + a legality violation; fresh(e) → rows(s, e) (REPLACES in the fold + even though + the store accumulates — divergence between an accumulating store and + a replacing contract is precisely the union pathology). + [Post-freeze editorial, two-track seam: the fold algebra these + rules implement — REPLACES absorption, OVERLAY composition, + tombstone ordering, replay-copy idempotence — is mechanically + proved in `formal/occult/LAWS.md` (L1–L6 plus negative controls); + the model consumes the laws as assumptions per the brief's + division of labor. No semantic change.] + Replacement-count legality counts committed copies WITHIN COMPLETE + ROUNDS, not verdict labels and not raw copy commits (round-7 F2 + pin): a copy inside a round that never completes is pre-committed- + classification debris and surfaces through content divergence, never + through the count — this keeps cell 4's locks-off run red (two + complete rounds, two counted copies), keeps 6-naive red (its debris + copy is uncounted; the alarm is content), and keeps the benign + cross-attempt at-least-once re-copy green (plan B5's "worst case … + re-runs an idempotent copy": attempt 1's incomplete-round copy plus + attempt 2's completed re-copy count as ONE); the locks-on run + copy-skips the duplicate and folds green. The FOLD'S INITIAL VALUE + IS THE EMPTY PARTITION (round-7 F3 pin): a scope with committed + store ops and no complete round diverges from the empty fold by + construction (never vacuously green), and a published manifest + entry for a scope whose fold result is EMPTY is an ATTESTATION + violation — the entry attests a composition the round log does not + contain. Checks: at SEAL — (a) CONTENT: partition equals the fold + result; (b) ATTESTATION: the manifest entry's epoch (via truthful + validators) equals the fold result's epoch, and an entry over an + empty fold violates outright; (c) CONFIG: every row's + ghost config tag equals the sealing attempt's compat config. At + `publish(s, v)` — ATTESTATION ONLY: v's epoch equals the publishing + round's verdict epoch (plan B5 permits the replay page to publish the + new delta token before overlay pages land, so no content check at + publish). The phantom union fails content or attestation in every §9 + variant; case 4's duplicate copy violates the at-most-one-replacement + rule directly; case 5a's drift copy fails config. BOUNDARY: TORN + completed rounds are outside P1-content's designed domain — under + between-attempt mutation a torn fresh round legally mixes epochs + (pure smear) and the per-round fold would false-alarm. No §9 config + can tear a round (each config's single stop is consumed by its + premise, each schedules at most one mutation, and crash-based + configs — scenario 6 — cannot tear: crash-only histories resume + from root-token checkpoints, §3/§5), so no scripted + verdict is affected; widening any config to a second interruption + plus a second mutation REQUIRES a fold extension for torn rounds + (per-page folding) via change order first. +- **P2 — bounded staleness (safety, multi-sync).** Ghost provenance per + row: origin epoch and the chain of syncs it traveled by replay. + "Consulted against upstream during sync N" is pinned as: the scope + had, during sync N (any attempt), a verdict that included an upstream + VALIDATION MATCH (`eValidate` == true), a fresh fetch, or a + CHANGED-WITH-DIFF verdict (revalidation occurred and the diff is an + upstream fetch; round-5 F8 pin) — a lookup + hit alone does NOT qualify. At each seal: every row's scope was + consulted-against-upstream this sync. Staleness counter per row; + corollary runs assert staleness ≤ 1 while P1 holds and exhibit + unbounded growth (to the chain bound) in the case-1 corrupted chain. +- **P3′ — per-scope epoch coherence (safety), doubly scoped.** Checked + ONLY (i) in scenarios without mid-attempt upstream mutation, and + (ii) for scopes with no TORN round this sync (a round crossing an + attempt boundary via mid-chain stop-resume observes two epochs and + would false-alarm). At seal, for every in-scope manifest scope: + partition content equals `rows(s, e)` for the epoch e of the scope's + last consulted-against-upstream verdict this sync ("last" by + announce order across attempts). Justification (valid in this class): + with upstream fixed within an attempt and no torn rounds, every page + of a round observes one epoch; truthful overlay composition preserves + coherence. Scenarios outside the class rely on P1/P2; a per-page + refinement is future work, not silently assumed. +- **P4 — progress.** Liveness form: after crash/stop budgets exhaust + and upstream mutation stops, the chain eventually seals (P liveness + monitor, hot while unsealed) — meaningful only with `abandonLadder` + on. Livelock DETECTION is a safety rule checkable in bounded runs: + two consecutive resume attempts that fail from byte-identical + restored checkpoint state with the same verdict at the same step + constitute the deterministic re-failure finding (CO-6b-004's + stuck-resume contract). The leaked-lock hang is checked via §4's + in-attempt retry: with the release edge removed, the retry deadlocks + (the model's own mutation check); with it present, the scenario + seals. +- **P6-A — session laundering witness (safety, variant A).** Ghost: + session values carry (writer action, attempt, derivation id); + committed outputs embed the stamps they read. At seal: violation iff + an embedded stamp's derivation differs from that writer's FINAL + derived value for the key — the artifact holds conclusions from + premises the final sync state does not hold, and no mechanism marked + it. Same-value re-derivation (d1→d2→d1) does not alarm. DOMAIN + (round-6 pin): P6-A quantifies ONLY over stamps embedded by session + reads performed within the sealing sync; traveled (replay-copied) + stamps and ⊥/miss stamps are outside its domain and belong to P6-R — + P6-A is vacuously green on 7a/7b/7c. +- **P6-R — replay-session coherence (safety, scenario 7; signoff + addendum).** Extends variant A's ghost vocabulary two ways: (a) + session-derived stamps TRAVEL WITH COPIED ROWS (replay copies ghost + provenance unchanged); (b) per (sync, key) the model carries a + COUNTERFACTUAL session value — the producer policy's PHASE-FINAL + value under an all-fresh execution at this sync's epoch, its reads + evaluated against the empty per-sync namespace (non-circular: the + namespace starts empty, the key budget is 1, and the producer phase + runs first). The counterfactual is computable, not a second + execution, because policies are deterministic and kinds run in + sequential phases with no cross-op spawns (a scenario-7 config + constraint) — which also makes it independent of reader timing: + every R read happens after W's phase completes (§8 note). It is + defined ONLY for scenarios whose upstream mutations are scheduled + BETWEEN SYNCS (a single epoch per (sync, scope) per sync; + between-attempt mutation within a sync makes "this sync's epoch" + multivalued and is excluded). At seal, for every committed row whose + scripted derivation includes a session input: violation iff the + row's embedded stamp differs from the counterfactual value of that + key this sync. Covers both duals: a fresh reader deriving from a + READ-MISS whose scripted producer was elided (7a — counterfactual + v1, embedded miss), and a replayed row carrying a stamp the producer + re-derived differently this sync (7b — counterfactual v2, embedded + v1). The both-warm control (7c) is green by construction: unchanged + upstream makes the counterfactual equal the carried stamp. P6-A is + unchanged and keeps its final-value form for within-sync laundering; + P6-R is the cross-sync/replay form. + +P5 (sweep) and P7 (sealed cuts) are graph-runtime properties — addendum. + +## 8. Abstraction soundness arguments (for the adversarial review) + +- **Clear/copy as two atomic steps.** Every calibration window is + BETWEEN named steps: gate↔clear (case 4), clear↔copy (record-page + wipe, CO-6b-006 N1), copy↔mark (carrier-less phantom, §9 1c), + stop↔spawn-drain (§9 stop-stranding premise). Sub-batch + partial-commit convergence: 6a store-level exclusion. +- **Checkpoint-or-skip nondeterminism** over-approximates the timer + throttle; forced sites (Init, pre-seal, stop) are preserved exactly. + Every model checkpoint placement is a real placement. +- **Batch cap {1..2}**: §1 scaling argument (two-way splits compose; + in-batch spawn admission makes width > cap reachable). +- **Verdict-as-data**: connector obligations (replay only a this-sync + hit, partition discipline) are deliberately violable by scenario + policy; SDK guards must catch the violations the contract says they + catch, and honest policies must not trip them. Policy PURITY + under-approximates legal connectors (the proto permits within-sync + connector memory, and the CO-6b-006 chaos connector uses it); all §9 + premises route verdicts through page tokens or the session store, so + no premise depends on cross-call memory. A future scenario needing it + is a change order, not a silent extension. +- **Session KV in MStore's durability domain**: the model gives session + writes op-commit durability and the store's crash cut. The production + session store is a separate service whose commits are NOT + prefix-ordered with c1z writes (and noop/in-memory variants are + lossy). The brief pins variant A as durable, so this is recorded as + the trust boundary of P6-A's verdicts, not modeled. +- **Counterfactual session ghost (P6-R)**: scripted-policy determinism + plus sequential kind phases (no cross-op spawns in scenario-7 + configs) make "the session value an all-fresh sync would hold" a + computable ghost label, not a second execution — no ∀∃ obligation — + and reader-timing-independent (every read follows the producer + phase). Pinned as the producer's PHASE-FINAL value (§7). Sound only + while scenario-7 configs schedule upstream mutation between syncs, + never within one (mid-attempt or between attempts); a config + violating that requires a P6-R scoping extension by change order. +- **One STORAGE row kind, 2 row ids**: sufficient to distinguish base + rows from fresh rows so unions and resurrections are content-visible. + Scenario 7's KIND axis ((op, scope) pairs, §1) rides on top without + widening storage row kinds. +- **Session-derived content divergence is under-approximated to ghost + stamps (scenario 7)**: real session-derived enumerations diverge in + CONTENT; §3's policies never choose row content, so the model carries + the divergence in the embedded stamp alone. The finding survives the + abstraction — the real system has no content oracle for fresh rounds + either, so the corruption is invisible to shipped checks for the + same structural reason. +- **Seal as one step**: the real counts-before-ended_at fence is + store-level, closed in 6a/6b. +- **Root-tokens-at-loop-tops is a claim about the modeled population.** + Every annotation-bearing listing (resources/entitlements/grants) runs + inside batches via `syncOneAction`, where it holds. Sequential + non-fanned ops (e.g. `SyncResourceTypesOp`) process one page per loop + iteration and CAN checkpoint mid-chain at loop tops in crash-only + histories; they are outside the model, and future scenarios touching + them must not inherit the batched-population claim. + +## 9. Calibration scenarios + +Expected-fail runs use the shipped design unless stated; every FIND must +be a checker counterexample trace (regenerable on demand from its +CALIBRATION.md cell row; sweep summaries are archived under +`walker/traces/`), rendered per deliverable 6. Every premise below +states its reachability +route; the standard premise generator is the STOP-STRANDING pattern: a +planning page's transition commits (hit recorded, same-op carrier +admitted to live state), the stop lands before the carrier's first +atomic step completes — undequeued or dequeued-but-unstarted both +qualify (genuine interleaving choice) — and the forced stop-checkpoint +makes {parent cursor, pending carrier, hit map} durable together. + +1. **Phantom union** (2 syncs + 1 verification sync, 1 scope, shipped + toggles ON — the residual exists in the shipped design). Premise for + 1a/1b: sync N+1 attempt 1 runs planning action P (2 pages): page 1 + consults S at epoch 1 (lookup hit V1 recorded, validation MATCHES, + verdict replay) and spawns carrier C (same-op, replay annotation V1 + in its token); stop-stranding: forced checkpoint captures P + mid-chain (page-2 cursor), C pending, hit {S: V1}. Between attempts + upstream → epoch 2. Attempt 2 restores both actions; P's page 2 + re-consults per policy: lookup hit V1 (overwrite, same value), + revalidation vs epoch 2 FAILS → verdict fetch-fresh → P's chain + continues with a 2-page fresh round under V2. C and P interleave + (same batch, 2 workers, or cap-1 orderings — genuine choices): + - **1a**: C drains between P's fresh pages → clear wipes the first + fresh page, copy installs base(e1), second fresh page lands on + top; P publishes V2 at round end → partition = base(e1) ∪ partial + fresh(e2) ≠ fold (fresh round replaces) → **P1 content violation** + at seal; chain continues, unchanged upstream → union replays → + **P2 staleness 2** (unbounded branch). + - **1b-i** (C drains after P's complete fresh round; C's annotation + publishes V1): clear wipes the fresh round, copy installs + base(e1), entry V1 → fold (fresh(e2) then replacement(e1)) = + rows(e1); content and attestation coherent → P1 green, **P3′ + violation** (last consulted verdict epoch 2, content epoch 1; no + torn round for S — P's consult pages and the fresh round each + commit within one attempt). + - **1b-ii** (C drains last, defers publish — validator-less page, + legal per proto): partition rows(e1) under entry V2 → **P1 + attestation violation**. + - **1c — carrier-less variant** (priority trace for the chaos + bridge; needs NO stop and NO spawn): attempt 1's single root + action consults S (hit V1, validation matches at epoch 1) and + replays in the same page; `eCopyScope` COMMITS; hard crash before + any post-Init checkpoint — durable base(e1) partition debris, hit + and replayed mark lost. Epoch 2; attempt 2 restarts from root, + re-consults, revalidation fails → fetch-fresh → upserts land over + the debris (fresh never clears) → publish V2 → **P1 content + violation** with ONE crash and NO replay in attempt 2 (warm gate + and binding never evaluated). + - **Fix runs — DE-SCOPED v11, not built** (`compositionEnum` on, + its real checkpoint-durable + syncer-side semantics): 1a/1b — detection fires, `blocked` reaches + the seal, sync N+2 runs cold, P2 restored from N+2. 1c — detection + CANNOT fire (no syncer-visible copy evidence); the propagation + bound fails; this is a REQUIRED finding of the run and bounds the + deliverable-3 claim. Crash-between-detection-and-checkpoint is a + second required finding. Kept as the reviewed design record of + the staged mitigation; the built fix story is §9.6's atomic unit + (1a/1b/1c re-runs green under V-ATOMIC, no detection machinery). + - **1d — overlay-flavor control (signoff addendum; content-green + under shipped toggles)**: same stranding premise as 1a/1b, but + attempt 2's failed revalidation yields CHANGED-WITH-DIFF + (delta-overlay flavor), not fetch-fresh: P's chain continues with + an overlay round — replay page (annotation V1, base e1), then + overlay pages (e1→e2) — while stale carrier C (pure replacement, + base e1) interleaves freely. V2's publish placement is pinned, + and BOTH placements are explored as sub-configs: (i) round-end + (final overlay page carries V2); (ii) B5 early publish (replay + page publishes V2, overlay pages validator-less). Expected: + CONTENT GREEN in EVERY schedule UNDER SHIPPED TOGGLES — both + copies draw the same base(e1) and collapse under `oncePerScope` ∧ + `scopeLocks` (the check-then-mark collapse is atomic only under + the lock; this is case 4's dual-replay shape, whose cell kills + each leg — a `scopeLocks`-off 1d mutant is content-red), and the + overlay composes legally onto either copy; the union cannot form. + The protection is MITIGATION-DEPENDENT, not structural + (V-OVERLAY-UNIT, §9.6, pilots the structural alternative — v10). + ATTESTATION is schedule-dependent by PUBLISH order, not drain + order: when a validator-bearing C's V1 publish is the LAST + publish for S (§4 runs `ePublishEntry` even on a copy-skipped + page), the seal sees entry epoch e1 under content rows(e2) → + expected ATTESTATION-STALE-BEHIND finding. Under sub-config (ii) + a C draining MID-schedule can still publish last (V1 after the + round's early V2); under (i) only C-drains-after-round-end + schedules alarm. Classification: stale-BEHIND is the self-healing + direction (the next sync's V1 consult re-delivers the e1→now + changes) only under idempotent absolute-record overlay + application — a connector-semantics assumption OUTSIDE the pinned + trust boundary — so P1 stays direction-blind and the cell records + the finding rather than weakening the property. A validator-less + C is rowless and legal (B5: a round that never publishes leaves + no entry — the replay itself remains valid); whether its copy + commits is SCHEDULE-dependent, not a property of + validator-lessness: C-first schedules COMMIT C's copy (the + annotation validator plays no part in the hit or base-binding + checks) — a committed replacement folding to rows(e1), counting + toward replacement legality, with P's round then folding as a + copy-skipped overlay to rows(e2); C-later schedules copy-skip C — + the §7 no-op, with no publish. Fully green in all schedules + either way. P2: GREEN (changed-with-diff qualifies as + consulted-against-upstream per §7's round-5 pin; staleness ≤ 1 — + base rows one replay hop, overlay rows fresh). Flavor-coverage + note (EXTERNAL-BOUNDARY commentary, §8-style — a + connector-population claim outside the model): the protection is + FLAVOR-conditional, not connector-conditional — delta connectors + degrade to fetch-fresh on token expiry (Graph 410), so 1a/1b/1c + cover every connector's degraded path. Fold totality over 1d logs + is pinned by §7's self-grounding-overlay and + copy-skipped-replacement clauses (added with this cell). + Provenance: this cell replaced a conversational "every ordering + converges" claim that had checked content only — the attestation + edge was caught while scripting the cell, which is the point of + scripting it. +2. **Session laundering** (1 sync, 2 same-op actions H (session writer) + and G (session reader), sessions variant A). Both cells are expected + findings; the property must alarm on exactly the schedules below and + stay green elsewhere. + - **2-stop** (deterministic script): one batch, two workers; the + explored schedule has H's session write of d1 commit (op-commit + durable), G read d1, emit a row embedding d1, and finish; graceful + stop aborts the batch while H is mid-chain; stop-checkpoint + captures G popped, H on the stack. Resume: H alone re-runs; + upstream mutated between attempts → H derives d2 ≠ d1; G never + re-runs → its committed row embeds d1 ≠ final d2 → **P6-A + violation** at seal. + - **2-crash** (interleaving-dependent, real shipped behavior): hard + crash before any post-batch checkpoint → BOTH re-run + (at-least-once). The schedule where G re-runs BEFORE H's + re-derivation exists (worker interleaving is a genuine choice): + G re-reads the DURABLE stale d1, re-emits embedding d1, H then + derives d2 → **P6-A violation**. The complementary schedule + (H re-derives d2 first, G re-emits embedding d2) stays green — + both outcomes are required calibration results. + - No fix run (variant B is the graph addendum's obligation). +3. **Artifact swap + hit rebind** (2 sealed artifacts A/B, equal compat + records, validators V_A ≠ V_B; upstream unchanged throughout, so + truthful validators give rows(B) ≠ rows(up) = rows(A)). + - **3A** (shipped: `hitValidatorBinding` ON, `annotationBinding` + OFF — the residual hole): premise = stop-stranding with a 2-page + P: page 1 consults base A (hit V_A, validation matches), spawns C + (annotation V_A); stop; checkpoint {P mid-chain, C, hit V_A}; + MEnv swaps the previous artifact to B. Attempt 2: P's page 2 + re-consults — lookup hit V_B OVERWRITES the hit map (lookup-time + recording, last-write-wins) even though revalidation of V_B + FAILS → verdict fetch-fresh (a 2-page round under V_up = V_A + content). C drains: hit check ✓, base-binding compares hit (V_B) + to base B's manifest (V_B) — PASSES — clear+copy installs + rows(B); C's annotation publishes V_A. Interleavings: C last → + partition rows(B) under entry V_A → **P1 attestation violation**; + C first or interleaved → fresh upserts land over rows(B) (fresh + never clears) → **P1 content violation**. **P2 is GREEN** in every + cell — attempt 1's validation match of V_A qualifies the scope as + consulted this sync (corrected expectation; v2 wrongly claimed a + P2 violation). + - **3B** (pre-CO-6b-004: `hitValidatorBinding` OFF): 1-page P + (consult+spawn, pops at the stop checkpoint); no re-consult in + attempt 2, hit map stays V_A; C drains against swapped base B with + NO binding check → copy proceeds, publish V_A → **P1 attestation + violation** on an even weaker premise. Binding ON flips this cell + to loud cold (V_A ≠ V_B) — the CO-6b-004 kill. + - **Fix runs — DE-SCOPED v11, not built** (`annotationBinding` ON, + shipped toggles): 3A — + annotation (V_A) ≠ recorded hit (V_B) → loud cold, no wrong data; + with `abandonLadder` on the chain completes cold (P4). Required + extra cell: a carrier whose annotation validator is EMPTY (legal + per proto) — the run must surface the fix's coverage boundary + (fail cold on absence, or the fix is incomplete for validator-less + connectors) rather than overstate it. Kept as the reviewed design + record; V-ATOMIC subsumes the fix (no carrier, no annotation to + bind — §9.6 case-3 re-run), including the validator-less coverage + boundary, which is structurally absent there. +4. **Once-per-scope TOCTOU** (1 sync, 1 scope, 2 workers, dual replay + carriers spawned same-op — both drain within one batch, no stranding + needed; delta-overlay round). Premise constraint (§3 dedup is + semantics, always on): the carriers carry BYTE-DISTINCT page tokens + encoding the same (scope, verdict) — distinct identity digests, so + both are admitted; this is the realized shape in the CO-6b-003/005 + chaos instruments (pages from different resources targeting one + scope). Literal byte-identical duplicates would be rejected + commit-locally or skipped by the spawned-admitted guard and CANNOT + produce this premise. With `scopeLocks` OFF, both + carriers pass the replayed-set check before either marks → + clear/copy runs twice; the second replacement wipes the first's + overlay upserts → **P1 violation** (two replacement copies violate + log legality; content check catches the resurrection). With locks + ON: single copy, overlays preserved, green under bounded + exploration. Lock-release mutation check per §4/§7 P4. +5. **Warm-drift** (1 sync, 1 scope; the `warmGate` kill and the produce + triggers). Premise = stop-stranding: attempt 1 (warm, config K1) + records hit {S: V1} and strands carrier C; between attempts MEnv + changes the declared drift input: + - **5a — compat drift (trigger 1)**: attempt 2 computes config K2 → + G7 mismatch → COLD, and B4 marks produce-blocked. `warmGate` ON: + C's warm-gate check fails → loud cold; artifact blocked; with + `abandonLadder`, next sync runs cold — no wrong rows. `warmGate` + OFF: C passes hit (restored) and binding (base unchanged, V1) → + copies K1-tagged rows into a K2 attempt → **P1 config violation** + (clause c). This is the warmGate kill (§6). + - **5b — capability withdrawal (trigger 2)**: attempt 2's G6 bit is + off (no source-cache handling). At attempt start, install observes + prior-attempt produce state without handling → produce-side block + (trigger 2) marks the artifact replay-blocked (checkpoint-cadence + durability; the crash-window finding is required here too). C's + replay-annotated page then arrives in the handling-less attempt + and is SILENTLY IGNORED per §4 (B1): no failure, no rows for S, + and the sync SEALS GREEN with partition[S] empty and the artifact + blocked. The green seal, cold consults, compat-record retention, + and blocked marking match the CO-6b-005 capability-withdrawn chaos + cell; the EMPTY-PARTITION DROPOUT is NOT pinned by that cell (its + connector adapts cold on miss — no stranded carrier exists there), + so the model's scripted seal-state expectation is the dropout's + only executable oracle today. + The silent scope dropout is a REQUIRED DESIGN FINDING of this + cell: it is green under P1 — the empty partition equals the empty + fold, and no entry exists to check (round-7 F3 wording pin; NOT + "vacuously green": a scope with no complete round is still + checked, against the empty fold) — and invisible to P2 (which + quantifies only over rows present), so the + cell's oracle is the scripted seal-state expectation itself. + Whether a completeness/coverage oracle should exist is recorded as + a deliverable-6 chaos-bridge question, not invented at freeze + time. + - **C1 probe** (CO-6b-002 conformance question): action A: page 1 + consults S (hit recorded at lookup) and records fresh; page 2 + carries a replay annotation (policy places replay mid-chain); stop + between the pages → checkpoint holds A's mid-chain cursor + the + hit map. Resume: page 2's connector call performs NO fresh + consult; the SDK hit check passes on the RESTORED hit map → the + replay runs on a mid-chain resume without a fresh consult. The + model thus answers C1 "reachable via the stop path" — a + conformance finding against CO-6b-002's "unreachable in practice" + wording, to be confirmed or refuted against the real + implementation through the chaos bridge (deliverable 6), not a + model bug. +6. **Atomic-unit design variant — collect-and-commit (signoff + addendum; bake-off pair, deliverable-4 pilot).** Not a §6 toggle + (it alters commit structure rather than removing a check): a + scenario-local variant of §3/§4/§5. V-ATOMIC pins the discipline + "complete one request's work before any derived work, marker + included": (i) replay executes INLINE on the consulting page — no + carrier spawn — and the page's own transition commits only after + (ii) ONE atomic store op `eReplayUnit(s)` = {clear, copy, marker, + publish} (implementation shape: single WriteBatch under a memory + threshold, grouped SST ingest above it — range-del + rows per key + family + marker row in one manifest edit; the model checks the + unit's CONTENTS, not the mechanism); the marker is a PER-SCOPE + STORE ROW, durable at op commit — AUTHORITATIVE consult provenance + (the marker) leaves checkpoint-cadence durability; (iii) a + re-executed action checks the marker BEFORE consulting and + suppresses re-consult and re-derivation for marked scopes. V-NAIVE + is the internal kill: marker-after-work WITHOUT the unit — shipped + §4 steps, then a separate marker op after `eCopyScope`; clause + (iii) applies to BOTH variants (V-NAIVE's defect is solely the + marker landing outside the unit). Under both variants the §5 + checkpoint token is UNCHANGED — the hit map and replayed set are + still recorded and checkpointed as shipped, but a restored hit + NEVER authorizes replay without a fresh consult: replay is + consult-inline, and marked scopes suppress the consult. A stop + between a lookup-hit and the unit can checkpoint {S: V1} with + nothing materialized; that stranded hit is INERT. Scope of the + pilot: originally FETCH-FRESH flavor only; the v10 addendum extends + it to the changed-with-diff (overlay) flavor via V-OVERLAY-UNIT and + cells 6-overlay / 6-overlay-naive below, which answer the two + obligations this paragraph previously deferred to deliverable 4 + (what the unit publishes for a diff verdict; the stale-AHEAD hazard + of a marker committing before overlay pages land — the latter is + 6-overlay-naive's kill). Boundary note + (round-5 N4): clause (iii)'s marker check precedes the consult + OUTSIDE the scope lock — itself a check-then-act window; two + concurrent consulting actions for one scope would both pass and + commit two units (two committed copies → P1 legality alarm). + Unreachable in this scripted single-consulting-action family; + recorded as a real 2-worker hazard for the deliverable-4 bake-off + boundary notes. + - **6-naive (expected RED — the debris union)**: 1 sync + resume, + 1 scope, fetch-fresh flavor, no post-Init checkpoint before the + crash. Attempt 1: consult S → verdict replay → clear+copy commit; + the hard crash lands in MStore's queue BETWEEN `eCopyScope` and + the marker op (same-sender FIFO prefix, §5 — reachable). One + between-attempt mutation (e1→e2). Attempt 2 restarts from root: + no marker → re-consult → revalidation fails → fetch-fresh; the + fresh round accumulates over the COMPLETE unmarked copy. Fold = + fresh(e2) (the interrupted replay round never completed; its copy + is debris) → **P1 content violation**, rows(e1) ∪ rows(e2) under + V2 — the phantom union rebuilt from debris with no carrier and no + stranding. (Shipped batched commits make PARTIAL-copy debris the + same way through an intra-copy window — 6a store-level + vocabulary, deliberately NOT §7's cross-attempt TORN; the + complete-copy window is the minimal witness and needs no + refinement of §8's copy-as-one-step abstraction.) + - **6-atomic (expected GREEN across this schedule and the 1a/1b/1c + re-runs)**: same schedule under + V-ATOMIC — a crash before the unit leaves nothing durable (resume + re-consults over an empty scope; the fresh round lands clean); a + crash after it leaves {rows(e1), entry V1, marker} together, and + resume suppresses re-derivation → seals coherent rows(e1)@V1, + with the e1→e2 changes arriving next sync via V1's consult. + Round-completion pin (round-5 F1): under V-ATOMIC the replay + round is COMPLETE at `eReplayUnit` commit — even when the + action's transition never commits and the re-execution is + marker-suppressed, the fold sees replacement(e1) and the seal is + green as scripted; under V-NAIVE the marker op is one of the + round's prescribed store ops, which is exactly what leaves the + 6-naive round incomplete. + Additionally re-run the 1a/1b/1c premises under V-ATOMIC with + `compositionEnum` OFF — expected green across those premises: the + stranding premise is unreachable (no carrier; durable consult + PROVENANCE — the marker — is atomic with materialization; a + checkpointed hit-map entry may precede it but is INERT, see + above), and 1c's debris cannot exist (the + marker rides the unit, so attempt 2 suppresses the second verdict + instead of unioning over debris). Also re-run the CASE-3 premise + (v11 extension, part of the de-scope decision): stop after + attempt 1's consult, base swapped to sibling B between attempts, + `annotationBinding` OFF — expected GREEN, because the variant + SUBSUMES the annotation-binding fix: there is no carrier and no + annotation to trust, restored hits are inert, and the marker + lives as a per-scope row in the CURRENT sync's artifact (not the + swapped previous one) — if attempt 1's unit committed, the seal + is that unit's coherent contents; if it did not, attempt 2 + re-consults against whatever base is ACTUALLY current (swapped + B's V1 fails validation against upstream e2 → fetch-fresh). The + 3A residual hole (hit-map rebind) is structurally closed for the + same reason: no restored hit ever authorizes replay. The pair + pins the two + load-bearing lines — the unit's contents (6-naive red shows the + marker must ride inside it) and marker-suppresses-re-execution — + and is the walker-side pilot of the deliverable-4 bake-off: the + graph runtime takes (i) as native scheduling semantics (derived + work is downstream of its premise's commit). + - **V-OVERLAY-UNIT (v10 addendum — the overlay-flavor extension of + V-ATOMIC).** Scenario-local variant of §3/§4/§5, declared here in + full before its cells (round-6 process lesson). The discipline + generalizes clause (i) — BOTH halves of it (round-7 F1): the + "request" whose work must complete is + the CONSULT VERDICT, not one wire page — for a CHANGED-WITH-DIFF + verdict the prescribed work is the base replay PLUS every overlay + page the diff yields. Pins: (o-i) replay-and-overlay executes + INLINE on the consulting chain — no carrier spawn (1d's stale + carrier cannot exist) — AND the transitions of every page in the + verdict's prescribed work commit only AT UNIT COMMIT (clause + (i)'s second half, generalized): intermediate overlay cursors + never enter live state, so a stop-forced checkpoint captures the + chain AT ITS CONSULT-PAGE TOKEN, which is the token resume + re-enters with. The deferral is scoped PER VERDICT, which keeps + multi-scope chains well-defined (MS-CO-001, parallel-review F4): + a page belonging to scope S1's committed unit has its transition + committed WITH that unit, so a chain stopped while consulting S2 + checkpoints at S2's consult token — never inside either scope's + prescribed work; (o-ii) under the variant, `eUpsertPage`/ + `eTombstones` for the scope are BUFFERED in a per-scope volatile + collect buffer (§5 row; bounded by pages-per-round ≤ 2, within + small scope) — no store op commits per page; when the FINAL + overlay page is collected, ONE atomic store op `eOverlayUnit(s)` + = {clear, copy(base e_from), overlay upserts/tombstones in + prescribed page order, marker, publish(V_to)} commits + (implementation shape as V-ATOMIC: WriteBatch or grouped SST + ingest; the model checks contents, not mechanism). Announce + vocabulary is unchanged: the unit announces its constituent ops + at commit, so every page of the round commits simultaneously and + round completion IS unit commit — the round folds as §7's + existing SELF-GROUNDING OVERLAY (own copy committed, folds to + rows(s, e_to) regardless of prior fold value, copy counting + toward replacement legality); no new fold clause. (o-iii) THE + UNIT ANSWERS THE DEFERRED PUBLISH QUESTION: it publishes V_to, + the verdict's post-diff validator (the new delta token), + attesting e_to. The publish constituent is present IFF the round + supplied a non-empty validator (round-7 F4: validator-less diff + rounds are legal per §3/B5) — a publish-less unit commits + {clear, copy, overlays, marker}, leaves NO entry (a miss next + sync, B5-consistent), and its marker still suppresses + re-execution within the sync. Timing (round-7 F5 rewording): the + variant DEFERS THE RUNTIME'S MANIFEST WRITE into the unit — a + deviation from B3/B5's frozen per-page publish timing, change- + order scope if adopted; the wire contract is untouched (the + connector still returns the token on whichever page carries it — + B5 permits either leg) and the deferral is connector-invisible + because the consult surface is the PREVIOUS artifact only + (`previousSyncSourceCacheLookup`). (o-iv) resume rule: the marker + suppresses + re-consult exactly as clause (iii); for a scope with NO marker, + resume restarts the scope's work FROM CONSULT — under (o-i)'s + transition deferral this is DERIVED, not decreed: the stop + checkpoint holds the consult-page token (no mid-chain cursor + exists for a unit-mode scope), the collect buffer is volatile, + and the honest price + is at-least-once re-fetch of the diff, lost work but never + debris. The stranded-hit inertness carries over from V-ATOMIC + unchanged; the marker-check-outside-lock two-worker hazard + carries over IN CLASS but with a MATERIALLY WIDER WINDOW + (round-7 F6): V-ATOMIC's window spans one page's handling, the + overlay variant's spans the whole collect phase (marker check at + consult → unit commit after every overlay page), multiple + connector calls wide. Because each unit is internally atomic, + the racing schedules' final content is the last unit's coherent + rows(e_to) — the alarm is legality-only (two committed copies), + never a wipe-mosaic. Recorded for the deliverable-4 bake-off + boundary notes. + - **6-overlay (expected GREEN across the re-scripted 1d premise + family — with `oncePerScope` AND `scopeLocks` OFF)**: the + structural claim that 1d could not make. 1d's stranding premise + is unreachable under (o-i) — no carrier — so the family is + re-scripted: planning chain consults S (hit V1, revalidation vs + e2 fails → CHANGED-WITH-DIFF), collects the 2-page ROUND inline + (the replay/first-overlay page plus the final overlay page — + NOT consult + 2 overlay pages, which would break §1's + pages-per-scope-per-round ≤ 2 bound; MS-CO-001), + `eOverlayUnit(s)` commits {base(e1) copy, overlay e1→e2, + marker, publish V2}. Sub-cases: (a) uninterrupted — fold = + self-grounding overlay → rows(e2), entry V2, content and + attestation green; (b) stop mid-overlay-chain — stop-checkpoint + captures the chain at its CONSULT-PAGE token (transition + deferral, o-i; round-7 F1 corrected this premise — no mid-chain + cursor exists to capture) and hit {S: V1}; buffer lost; + resume re-enters at the consult (o-iv, derived), re-consults + (restored hit is + inert), re-collects, one unit commits → green; (c) crash before + the unit — nothing durable for S, clean re-consult → green; (d) + crash after the unit — {rows(e2), entry V2, marker} durable + together, marker suppresses re-derivation → seals coherent. Both + mitigation toggles are OFF in every sub-case: `oncePerScope` is + unneeded (the marker inside the unit is the dedup; a re-executed + chain suppresses at the marker check) and `scopeLocks` is + unneeded within the scripted single-consulting-chain family (the + two-worker marker-race boundary note still applies and stays a + recorded hazard, not a scripted cell). 1d's + attestation-stale-behind cannot occur: publish order equals unit + order because no publish exists outside a unit. P2 GREEN + (changed-with-diff qualifies per §7's round-5 pin; staleness ≤ + 1). P3′ applies: no torn round is possible for unit-mode scopes — + every round commits within one attempt by construction. + - **6-overlay-naive (expected RED — the stale-AHEAD kill; the + inherited deliverable-4 obligation made concrete)**: unit + misdrawn at the consult boundary instead of the verdict boundary: + `eOverlayUnit'(s)` = {clear, copy, marker, publish(V2)} commits + at consult time, overlay pages then commit per-page via the + shipped §4 path. 1 sync + resume + 1 verification sync, 1 scope. + Hard crash lands in MStore's queue between the unit' commit and + the final overlay upsert (same-sender FIFO prefix, reachable as + in 6-naive). Attempt 2 restarts from root; the MARKER IS PRESENT + → clause (iii) suppresses re-consult and re-derivation → the + remaining overlay pages NEVER land; seal: partition = base(e1) + + partial overlay under entry V2. Fold: the round is INCOMPLETE + (prescribed overlay store ops never committed) → contributes no + fold entry → the fold for S is EMPTY, and the committed prefix + diverges from it by the §7 empty-fold pin (round-7 F3) → **P1 + content violation** at seal, plus **attestation violation** + outright: entry V2 is published over an empty fold (the entry + attests a composition the log does not contain). The + verification sync makes the direction asymmetry + 1d classified CONCRETE: consult of V2 revalidates CLEAN (upstream + unchanged at e2 — the per-seal consult clause of P2 is GREEN + there) → the mosaic replays warm → the **P2 staleness COUNTER + grows without bound** (round-7 F7 wording: the growth is on the + stale RESIDENT base(e1) rows whose e1→e2 updates never landed — + case 1's "unbounded branch"; the never-landed rows are in no + partition) and P1 content stays RED in the verification sync + itself (the warm mosaic copy folds as rows(e2) via truthful V2; + the partition is the mosaic) — stale-AHEAD is + the NON-self-healing direction (V2 attests changes the artifact + never absorbed; no future consult re-delivers e1→e2), the dual of + 1d's self-healing stale-BEHIND. The marker-before-pages placement + is the sole defect: 6-overlay commits the identical contents one + boundary later and is green. + - **6-overlay-last (round-7 F2 — the third placement, its own + cell)**: per-page commits with marker+publish LAST outside any + unit: clear+copy commit at the replay page, overlay + upserts/tombstones per-page via the shipped §4 path, then marker + and publish(V2) as two trailing separate ops. The round-7 review + REJECTED the v10 dismissal ("reduces to 6-naive's unmarked-debris + class"): the reduction is impossible in the overlay family — a + crash before the marker leaves UNMARKED debris, but attempt 2's + re-consult yields CHANGED-WITH-DIFF by premise, whose prescribed + work BEGINS with clear+copy — the clear WIPES the debris and the + round rebuilds; no schedule unions (6-naive's class requires a + NON-clearing fetch-fresh re-verdict). The placement's real + windows are its own: (w1) crash anywhere before the marker → + converging rebuild, GREEN — and the FIRST history in the spec + where replacement-count legality meets a cross-attempt double + copy (attempt 1's copy in an incomplete round + attempt 2's + completed re-copy), legal under §7's complete-rounds counting + pin (B5's idempotent re-run); (w2) crash BETWEEN marker and + publish → marked, entry-less, content-complete scope whose + re-execution clause (iii) SUPPRESSES → seals correct rows(e2) + with NO entry; the publish was a prescribed round op that never + committed → round incomplete → empty fold → **P1 content + violation** (non-empty partition vs empty fold) — a + suppression-window shape that is NOT 6-naive's union class + either. Expected: P1 RED (w2 is the witness; w1 must NOT alarm — + it exercises the counting pin). +7. **Session elision under replay — the sessions × source-cache + product (signoff addendum; shipped design, pure two-sync scripts — + no interruption machinery).** Two kinds: W (producer, in the + declared replay flow) whose fresh enumeration writes session key K + as a side effect, and R (reader) whose fresh enumeration derives + emitted rows from reading K (ghost stamp). Kinds run in sequential + phases (W's op before R's). Sync N is all-fresh: W writes K=v1, R + emits rows stamped v1, seal green. The shipped design has NO + coupling between sessions and source-cache + (`source_cache_orchestration.go` has no session awareness; + `BatonSessionService` is callable during any listing), so every + cell below runs shipped toggles unless stated. R's connector + violates NO pinned obligation in any cell — its validator + truthfully attests R's upstream scope; the session dependency is + un-attested because no contract clause requires attesting it. That + missing clause is the scenario's design finding. + - **7a — write elision (expected RED)**: upstream unchanged for W; + R runs fresh in sync N+1 (its policy fetches fresh; round-6 F9 + struck the per-kind flow-membership route as unmodeled). W's + consult → validator match → warm + replay; W's enumeration — and its session write — is ELIDED, so + sync N+1's namespace never holds K. R's fresh derivation reads K + → MISS → emits rows stamped ⊥. Row CONTENT stays on the rows + table by construction (§3: policies choose verdicts and session + ops, never row content), so the divergence is carried entirely in + the embedded ghost stamp. Counterfactual: v1 (an + all-fresh sync's W would have written it) → **P6-R violation**. + P1 and P2 are GREEN — every row is individually well-formed and + every scope consulted; the corruption is invisible to + content/attestation checks, which is itself a required finding — + and holds in the real system for the same structural reason + (fresh rounds have no content oracle; §8). + - **7b — stale-read replay (expected RED, the dual)**: between + syncs upstream W-data changes (W fresh in N+1, writes K=v2) while + R's upstream scope is unchanged (validator match → R warm). R's + copied rows carry ghost stamp v1; the counterfactual this sync is + v2 → **P6-R violation**. No elided write anywhere — the writer + ran fresh; the READER was replayed with rows derived from last + sync's session state. This is the cell that kills write-only + bans. + - **7c — both-warm control (expected GREEN)**: nothing changes + upstream; W and R both replay; carried stamps v1 equal the + counterfactual v1. Required so P6-R does not overfit to "replay + near sessions alarms". + - **Fix runs**: fix runs re-execute the FULL two-sync script with + the toggle ON — the toggles are produce-side, so the fix run's + sync-N artifact DIFFERS from the red run's (the first toggle + family that acts a sync earlier than the red verdict). Sync N is + COLD (first sync, no previous artifact) and the taint records + anyway: replay-capable is flow membership, not warm state (§6 + pins). `sessionTaintWrites` ON — sync N's produce observes + W's write during a replay-capable phase and marks W's kind + non-replayable in the artifact; sync N+1 runs W cold (consults + MISS — degradation, not a loud verdict) → 7a GREEN; + 7b stays RED (R's hazard is a READ) — the residual is a REQUIRED + finding: the write-only rule is half a fix. `sessionTaintAll` ON — + R's read during its capable phase (sync N) taints R's kind too → + 7a and 7b both GREEN; 7c runs cold for every session-using kind + (replay forfeited exactly where sessions are used — the toggle's + honest price, recorded not hidden). Taint granularity is per KIND + per artifact (phase attribution — kinds run sequentially, so no + wire change is needed); taint-to-cold vs loud-reject is a + severity choice outside the model — the detector is identical. + Out-of-model enforcement layers of the same detector + (change-order implementation work, recorded for the calibration + report): a static analyzer (call-graph from replay-capable + listing entry points to the session API, suppressible only by + the §6 opt-out attestation), a pre-release conformance assert + (per-response `SessionStoreUsage` attribution), and the runtime + taint itself — one detector, three timings. + +Fix-verification runs are bounded-exploration green runs (schedule +budget recorded in the calibration report), not proofs. + +Pre-committed classification (round-2 residual risk): out-of-script P1 +counterexamples of the cross-attempt fresh-debris shape (fresh pages +commit, crash, mutation, re-fetch unions over debris — no replay +involved) are DESIGN FINDINGS of the shipped walker, not model noise; +P1 must not be weakened to silence them. + +## 10. Adversarial review charge (minimum questions) + +0. Reachability walk: for each §9 premise, walk the route mechanically + under §3's semantics (spawn admission, batch draining, stop/crash + windows, checkpoint contents) and confirm the state is reachable + without hand-placement; confirm each cell's expected verdict follows + from §7's definitions (fold legality, P2's consult pinning, P3′'s + double scoping). +1. Interleaving: did the encoding serialize any calibration-relevant + pair (carrier drain vs fresh pages; record page vs replacement copy; + duplicate carriers; H vs G re-runs in 2-crash; crash vs in-flight + ops across two senders)? +2. Crash/stop: does crash wipe exactly §5's volatile column; is the + warm flag demonstrably not restored; is the prefix rule (§5) + enforced; do stop-checkpoints capture exactly the live state the + stop path captures in code (mid-chain cursors, admitted spawns, + batch-recorded hits)? +3. Emergence: do the §9 findings arise from stack/batch/stop/checkpoint + mechanics rather than scenario hand-placement? (Delete each + finding's trace; check no scenario step writes the corrupt state + directly.) +4. P1/P3′: is the fold deterministic and total over every §9 log; is + the publish-time check attestation-only; is P3′'s double scoping + (mid-attempt mutation, torn rounds) enforced by ghost state rather + than scenario labeling; is the truthful-validator assumption used + only inside the trust boundary? +5. Mutation adequacy: each BUILT §6 toggle's kill cell flips as tabled + (the v11 de-scoped toggles carry no obligation); the + P1 monitor alarms on 1a/1b-ii/1c, 3A/3B, 4, 5a, 6-naive, and 1d's + carrier-publishes-LAST schedules (attestation only; publish order, + not drain order), and stays green on honest delta overlays, 1d's + remaining schedules, the 6-atomic runs, and the case-3 V-ATOMIC + re-run (v11 — the subsumption claim); a `scopeLocks`-off 1d + mutant is content-RED (case 4's dual-replay TOCTOU); 6-overlay is + GREEN across its whole sub-case family with `oncePerScope` AND + `scopeLocks` OFF (the structural claim — the same toggles-off + configuration that turns 1d content-red); 6-overlay-naive is + content-RED and attestation-RED at seal (entry over an empty fold — + round-7 F3) and exhibits unbounded P2-counter growth in the + verification sync with P1 content still red there (stale-AHEAD, + non-self-healing); 6-overlay-last is content-RED via the w2 + suppression window and must NOT alarm legality on w1's + cross-attempt re-copy (the complete-rounds counting pin — round-7 + F2); an o-iv-REMOVAL mutant (resume honors a restored mid-chain + cursor for a unit-mode scope) is content-RED in 6-overlay + sub-case (b)'s schedule — the mutant collects only the final page + into an empty buffer and commits a unit missing the first page's + overlay ops (MS-CO-001, parallel-review F6; the round-5 F2 + precedent); P6-R alarms on + 7a and 7b, stays green on 7c and on fix runs as tabled (7b must + stay RED under `sessionTaintWrites`); the + lock-release edge's removal deadlocks §4's retry. +6. Composition enum: does the encoding match the PR-discussion + semantics, INCLUDING detection-state visibility and mark durability + across attempt boundaries? Are the 1c and detection-crash findings + reported as claim boundaries, not suppressed? + +## 11. Change-order log + +(Append-only after freeze.) + +- (pre-freeze) v2: round-1 adversarial review dispositions — see + `formal/reviews/model-spec-round1.md`. +- (pre-freeze) v3: round-2 adversarial review dispositions — see + `formal/reviews/model-spec-round2.md`. Headline changes: §9 + re-scripted on the stop-stranding premise generator (round-2 blocker + 1); scenario 2's hard-crash cell inverted to an expected finding + (blocker 2); P1 fold fully pinned with publish-time checks reduced to + attestation (finding 3); P3′ torn-round exclusion (finding 4); + scenario 3 expectations re-derived — P1-attestation, P2 green + (finding 5); scenario 5 added for warmGate and both produce triggers + (findings 6, 7); per-attempt G6 bit and compat config with P1 config + clause (findings 6, 7); oncePerScope toggle marker (finding 8); + glossary corrected (finding 9); C1 probe script (finding 10); §8 + notes for session-KV durability domain and connector purity (notes + i–iii). +- (pre-freeze) v4: round-3 adversarial review dispositions — see + `formal/reviews/model-spec-round3.md`. Headline changes: §4/§9-5b + corrected to B1's silent-ignore semantics with trigger 2 at install + time, and 5b's silent scope dropout (green seal, empty partition, + blocked artifact) promoted to a required design finding with a + scripted seal-state oracle (blocker F1 + note F7); P1 fold order + pinned to round completion (F2); action pops commit at completion, + mid-batch (F3); restart-from-root restated as a + which-checkpoint-survives property, §5 and glossary (F4); spawn + dedup extended to all admissions with commit-local duplicate + rejection (F5); stop-stranding window widened to + first-atomic-step-incomplete (F6). +- (pre-freeze) v5: round-4 adversarial review dispositions — see + `formal/reviews/model-spec-round4.md`. Cell 4's premise pinned to + byte-distinct page tokens encoding one (scope, verdict) (finding 1); + P1 fold gains the copy-skipped duplicate-overlay no-op clause and + committed-copies replacement counting (finding 2); produce-blocking + "two triggers" scoped to the modeled fragment with the excluded + triggers registered in §1 (finding 3); 5b's CO-6b-005 attribution + narrowed — the empty-partition dropout is pinned only by the model's + scripted oracle (note 4); root-tokens-at-loop-tops recorded as a + modeled-population claim in §8 (note 5); commit-local duplicate + rejection qualified as same-op-scoped (note 6). +- (pre-freeze) v5 signoff-discussion addendum: P1 torn-round fold + boundary recorded in §7 (torn completed fresh rounds under + between-attempt mutation are legal smear the per-round fold would + false-alarm on; unreachable in all §9 configs; config widening + requires a fold extension by change order). Surfaced while walking + the P3→P3′ narrowing during user signoff. +- (pre-freeze) v6 signoff-discussion addendum: overlay-flavor control + cell 1d added to §9 case 1 (content-green structural protection — + same-base copies collapse under `oncePerScope`; expected + attestation-stale-behind finding when the stale carrier's V1 publish + lands last; flavor-coverage note: token expiry degrades every delta + connector to the fetch-fresh flavor covered by 1a/1b/1c). §7 P1 + fold extended for totality over 1d logs: self-grounding overlay + rounds; copy-skipped replacement rounds fold as attestation-only + no-ops. Scenario 6 added — collect-and-commit design-variant pair + (V-NAIVE marker-after-copy → expected-red debris union; V-ATOMIC + inline replay + one {clear, copy, marker, publish} atomic unit with + the marker as a per-scope store row + marker-suppressed re-execution + → expected green across the 1a/1b/1c re-runs; deliverable-4 pilot). + Provenance: user signoff discussion (smear-vs-union attestation + distinction, copy atomicity, SST-ingest collect-and-commit). The 1d + attestation edge was caught WHILE SCRIPTING the cell, refuting the + conversational "every ordering converges" claim. These addenda have + NOT passed an adversarial round; a targeted spot review before + freeze is the recommended option. +- (pre-freeze) v7: round-5 targeted spot review of the v6 addenda — + see `formal/reviews/model-spec-round5-addenda.md`. REJECT, 2 majors + + 6 minors, all fix-without-re-review per the verdict; reachability, + fold totality, and 1d's content-green-under-shipped-toggles claim + otherwise confirmed, no contradictions with rounds 3–4. Headline + dispositions: page/round COMPLETION pinned to store-op commit + (announce-visible; transitions and pops are not fold events; a + round committing no store ops contributes no fold entry), with + V-ATOMIC's round complete at `eReplayUnit` commit and V-NAIVE's + marker op a prescribed round op (F1); 1d's protection re-attributed + to `oncePerScope` ∧ `scopeLocks` and demoted from "structural" to + mitigation-dependent, `scopeLocks`-off mutant added to §10.5 (F2); + validator-less-C sub-case re-scripted per schedule class — C-first + commits the copy, C-later copy-skips, green either way (F3); 1d + publish placement pinned as two explored sub-configs with + publish-order ≠ drain-order noted (F4); torn-round boundary + justification extended to crash-based configs and incomplete-round + debris named in the fold text (F5); V-ATOMIC's relationship to the + §5 checkpoint token pinned — hit map still checkpointed but never + authorizes without a consult, clause (iii) applies to both variants + (F6); 6-atomic's green claim de-scoped to the 1a/1b/1c re-runs and + the overlay flavor declared an explicit deliverable-4 obligation + (F7); P2's consult pin extended to changed-with-diff verdicts and + 1d's P2 expectation stated (F8). Freeze-record notes: partial-copy + vs torn vocabulary (N1); the self-grounding clause retroactively + closes a latent v5 fold-totality gap on case 4's locks-on surviving + round (N2); the flavor-coverage note labeled external-boundary + commentary (N3); V-ATOMIC's marker-check-outside-lock + check-then-act window recorded as a 2-worker bake-off hazard (N4). +- (pre-freeze) v8 signoff-discussion addendum: scenario 7 added — the + sessions × source-cache PRODUCT, a coverage gap both subsystems + individually modeled but no cell exercised. Shipped design has no + coupling (`source_cache_orchestration.go` session-blind; + `BatonSessionService` callable during any listing; sessions + sync_id-scoped so each sync's namespace starts empty). Cells: 7a + write elision (warm producer's elided enumeration never writes K; + fresh reader derives from the miss), 7b stale-read replay (fresh + producer rewrites K; warm reader's copied rows carry last sync's + stamp — the dual that kills write-only bans), 7c both-warm control + (green). New property P6-R (replay-session coherence): embedded + session stamps vs a counterfactual session ghost (scripted-policy + determinism + sequential kind phases make it computable — §8 note); + ghost stamps travel with copied rows. New PROPOSED toggles + `sessionTaintWrites` (partial — flips 7a only, 7b residual is a + required finding) and `sessionTaintAll` (isolation — flips both; + cost: replay forfeited for session-using kinds, recorded). Glossary + gains Elision and Session taint. Provenance: user signoff + discussion — the elided-session-write question, refined through the + read-side dual to per-kind isolation; taint-to-cold vs loud-reject + recorded as a severity choice outside the model. NOT yet + adversarially reviewed; targeted round-6 spot review required + before freeze. +- (pre-freeze) v9: round-6 targeted spot review of the v8 addendum — + see `formal/reviews/model-spec-round6-scenario7.md`. REJECT, 4 + majors + 5 minors + 3 notes, all fix-without-re-review; every cell + verdict and all six shipped-system claims verified clean. Headline + dispositions: the KIND axis declared in §1 as an (op, scope) pair — + storage row kinds unchanged, small-scope row added, §8 note updated + (F1); P6-A's domain pinned to stamps read within the sealing sync — + traveled and ⊥ stamps belong to P6-R; P6-A vacuously green on + 7a/7b/7c (F2); taint durability pinned checkpoint-cadence in §5/§6 + with the self-healing-under-re-execution argument claimed + explicitly (F3); REPLAY-CAPABLE pinned as flow membership + independent of warm/cold — the taint records in cold attempts, + which the 7a fix run depends on (F4); consume side pinned as + lookup-miss degradation in §3 (F5); P6-R scoping aligned to + between-sync-only mutation (F6); counterfactual pinned to the + producer's phase-final value with empty-namespace evaluation and + reader-timing independence stated (F7); 7a's ghost-only divergence + stated plus the §8 under-approximation note (F8); 7a's unreachable + flow-membership premise route struck (F9); modeled session surface + registered as Get/Set with WRITE covering all mutating ops in + production (F10); two-sync fix-run re-execution stated (F11); §3 + `eCopyScope` ghost tuple extended for stamp travel (F12). Folded in + from the same signoff discussion: the capability-level OPT-OUT + (attested emission-irrelevance; dishonest opt-out ≡ 7a/7b, honest + green by definition) and the out-of-model enforcement layers + (static analyzer, pre-release conformance assert, runtime taint — + one detector, three timings). +- (pre-freeze) v10: overlay-flavor extension of the atomic-unit + variant, per user direction at signoff — the walker-side pilot now + covers the changed-with-diff flavor rather than deferring it wholly + to deliverable 4. §9.6 gains V-OVERLAY-UNIT (unit boundary = the + consult VERDICT's prescribed work: base copy + all overlay pages + + marker + publish(V_to) in one atomic op; per-page ops buffered in a + volatile collect buffer, §5 row added; publish deferred into the + unit — B5 early publish not exercised; marker-absent resume + restarts from consult, mid-chain cursors ignored for unit-mode + scopes), cell 6-overlay (expected GREEN across the re-scripted 1d + premise family with `oncePerScope` AND `scopeLocks` OFF — the + structural claim 1d could not make; folds as §7's existing + self-grounding overlay, no new fold clause), and cell + 6-overlay-naive (expected RED — marker+publish at the consult + boundary, crash before the final overlay page; marker suppression + seals base(e1)+partial-overlay debris under entry V2, P1 content + violation, and the verification sync shows unbounded P2 growth: + stale-AHEAD is the non-self-healing direction, answering the + hazard scenario 6 had named and deferred). 1d cross-referenced; + §10.5 obligations extended. NOT yet adversarially reviewed; + targeted round-7 spot review required before freeze. +- (freeze revision) v11: round-7 targeted spot review of the v10 + addendum — see `formal/reviews/model-spec-round7-overlay.md`. + REJECT, 3 majors + 2 minors + 2 notes, all fix-without-re-review; + no cell verdict overturned; fold treatment, structural claim, + crash-window constructibility, and all shipped-system claims + verified clean. Headline dispositions: (o-i) generalizes BOTH + halves of V-ATOMIC's clause (i) — page transitions in a verdict's + prescribed work commit only at unit commit, so stop checkpoints + hold the consult-page token and o-iv's restart-from-consult is + derived; sub-case (b)'s premise corrected (F1); the third-placement + dismissal replaced with cell 6-overlay-last — the overlay + re-verdict CLEARS unmarked debris so no reduction to 6-naive + exists; its w2 (marker-committed, publish-lost suppression) is the + P1 witness and its w1 pins replacement counting to committed copies + within COMPLETE rounds (F2); the P1 fold's empty case pinned — + initial value is the empty partition, an entry over an empty fold + is an attestation violation outright, 5b's "vacuously green" + reworded (F3); the unit's publish constituent conditional on a + supplied validator — publish-less units leave no entry, + B5-consistent (F4); the publish-timing claim reworded as a + runtime-side B3/B5 deviation (change-order scope if adopted), + connector-invisible via the previous-artifact-only lookup surface, + "whichever page carries it" (F5); the two-worker marker-race note + extended with the widened collect-phase window, legality-only alarm + (F6); 6-overlay-naive's P2 wording corrected to the resident-row + staleness counter with the verification sync's P2 seal clause green + and P1 content still red there (F7). Bundled de-scope edits (user + signoff): `compositionEnum` and `annotationBinding` marked + DE-SCOPED — documented as reviewed design records, not built in P, + kill obligations removed (§6/§10.5); their fix duty is discharged + by the atomic unit as the single fix story, witnessed by the §9.6 + re-runs incl. the NEW case-3 re-run extension (V-ATOMIC subsumes + annotation binding: no carrier, no annotation, markers live in the + current artifact, restored hits inert). FREEZE: this revision is + the diffable baseline; subsequent changes are MS-CO-NNN change + orders, never silent edits. +- MS-CO-001: dispositions for the PARALLEL round-7 review + (`formal/reviews/model-spec-round7-overlay-parallel.md` — a second + independent spot review of the same v10 addendum, surfaced after + the v11 freeze; 1 major + 5 minors + 4 notes). Its major (empty + fold) and two minors (validator-less publish; publish-timing + wording) were independently found by the primary review and were + already fixed in v11 — the double-hit confirms those pins. Newly + applied here: `eReplayUnit`/`eOverlayUnit` and the marker ops + registered in §3's MStore op list as scenario-local, with a §4 + pointer to the variant override (F5) and a §5 durability row for + the marker (N1); o-i's transition deferral explicitly scoped per + verdict, making the resume rule well-defined for multi-scope + chains (F4 — v11's deferral pin already dissolved the ignore-rule + ambiguity the finding targeted); the collect pinned as the 2-page + ROUND (N4); and a NEW §10.5 kill obligation — the o-iv-removal + mutant is content-RED in 6-overlay sub-case (b) (F6), built as a + model cell. DISAGREEMENT OF RECORD: the parallel review judged the + third-placement reduction SOUND where the primary called it false + (round-7 F2); the built cell 6-overlay-last settles it + mechanically for the primary — the w2 marked-entry-less window is + red in a shape that is NOT 6-naive's union class, and w1 exercises + exactly the legality-counting gap the parallel review itself + flagged as its N3 tripwire. Its F3 (degenerate publish-placement + axis) is subsumed by v11's F5 rewording ("whichever page carries + it"); noted here that both B5 token placements collapse into the + single unit publish by construction. diff --git a/formal/README.md b/formal/README.md new file mode 100644 index 000000000..7d22acd42 --- /dev/null +++ b/formal/README.md @@ -0,0 +1,83 @@ +# Formal model of sync scheduling semantics + +This directory holds the P model of baton-sdk's sync scheduling semantics +and its supporting documents, per +`docs/tasks/sync-formal-model-brief.md`. This is a public repo: no customer +names, tenant IDs, or internal infra in any artifact here, including model +comments and trace renderings. + +## Contents + +- `REPORT.md` — the synthesis report: verdicts, findings register, + and the guarantee/non-guarantee boundary, with pointers into + everything below. Start here for the outcome; start at GLOSSARY.md + to work on the models. +- `GLOSSARY.md` — deliverable 0: pinned vocabulary. Read this first; every + other document and every P identifier uses these meanings. +- `MODEL_SPEC.md` — the frozen model specification (machines, abstraction + decisions, crash semantics, properties, calibration configurations). + Frozen before P code is written; deviations discovered during modeling + are appended as change orders, never silently absorbed. The spec receives + an adversarial review before any green checker run is trusted. +- `GRAPH_MODEL_SPEC.md` — deliverable 4: the demand-graph runtime model + spec (frontier scheduler, generations, sweep, lineage bake-off E vs S). + v4, FROZEN after three adversarial review rounds; inherits MODEL_SPEC's + conventions and adopts its design-variant verdicts (unit-mode + materialization) as settled hand-offs. +- `reviews/` — adversarial review rounds for the specs, one file per + round; dispositions are logged in the specs' change-order sections. +- `walker/` — P project: the tiered walker + source-cache replay (6b) + calibration model (deliverables 2–3). Calibrated and frozen; see + `walker/CALIBRATION.md`. +- `graph/` — P project: the demand-graph runtime model (deliverable 4). + Built after `GRAPH_MODEL_SPEC.md` cleared review. Calibrated and + frozen: the full 66-cell matrix (G1-G9) sweeps clean at 10k + schedules, plus the 12-cell bake-off phase (12/12 on declared + verdicts); see `graph/CALIBRATION.md` for the run log and the + calibration finds (GS-CO-001..005, G8B-CAL-1, G9-CAL-1). +- `graph/BAKEOFF.md` — deliverable 4's written recommendation: the + lineage bake-off verdict (variant S — observable-causal stamps), + assembled under GS-CO-005's registered decision rule. This is the + artifact the demand-graph RFC cites. +- `occult/` — the deductive track (deliverables 6–9): equational laws + of the composition algebra and stamp lattice proved by equality + saturation in the Occult engine (sibling repo `../occult`), the + trace-policy oracle set, the session-typed protocol contract with + per-role projections, and the trace-bridge note. Includes the + broken-vs-good pairing: the phantom union DERIVED deductively from + the broken composition rule, and an executable reference + implementation of the demand-graph runtime validated against the + trace oracle (legacy mode reproduces the broken behavior and is + caught). The trace bridge is closed against the SHIPPED syncer too: + `pkg/sync` chaos tests record real commit-order traces + (`pkg/sync/sync_trace_audit.go`) exported as fixtures and checked by + the same oracle. See `occult/README.md` for status and + `occult/LAWS.md` for the law inventory. + +## Toolchain + +The P checker (https://p-org.github.io/P/) installs as a dotnet global +tool: + +```bash +dotnet tool install --global P # p --version → 3.1.0 at time of writing +``` + +Build and check (from a project directory such as `walker/`): + +```bash +p compile +p check -tc -i 10000 +``` + +## Standing rules + +- Calibration before trust: the model earns authority by mechanically + rediscovering the known bugs (brief, "Calibration cases") with the + corresponding mitigations toggled off, and verifying the shipped/staged + fixes close them when toggled on. A green checker run means nothing + until the model has found the bugs we already know about. +- The model validates designs, not Go code. The bridge to the + implementation is trace-driven (deliverable 6). +- Candidate invariants are inputs to be checked, not assumptions; + refutation is a success. diff --git a/formal/REPORT.md b/formal/REPORT.md new file mode 100644 index 000000000..430ca6b2d --- /dev/null +++ b/formal/REPORT.md @@ -0,0 +1,282 @@ +# Sync formal verification — synthesis report + +This is the executive summary of the formal verification effort for +baton-sdk's sync scheduling semantics (charter: +`docs/tasks/sync-formal-model-brief.md`). It states what was modeled, +what was found, the verdict, and — as precisely as possible — what is +and is not guaranteed. Detail lives in the documents each section +cites. Public-repo content rules apply throughout. + +## The verdict in three sentences + +The current tiered-walker + source-cache-replay design mechanically +reproduces every calibration bug it was suspected of, including the +phantom union, with each failure caught by a dedicated monitor. The +proposed demand-graph runtime, after three adversarial spec reviews +and a calibration program that found and fixed five design bugs of +its own, is verified at small scope in both lineage variants, and the +registered decision rule selects **variant S (observable-causal +stamps)** — see `graph/BAKEOFF.md`. The shipped syncer's real +commit-order behavior has been witnessed conformant to the ordering +and durability policies on every execution we exported (cold, warm, +crash/resume, tombstone-delta), and the instrument is sharp enough +that it falsified one piece of documented resume behavior along the +way. + +## Track A — calibration model of the current design (P) + +`MODEL_SPEC.md` (v11, frozen after seven review rounds plus +MS-CO-001) and the `walker/` P project. Authority is earned by +rediscovery: with mitigations toggled off, the checker finds the +known bugs; with the shipped/staged fixes toggled on, the same cells +go green. The current sweep is 55 cells, 0 mismatches, 10k schedules +per cell (`walker/CALIBRATION.md`). + +Reproduced reds include: the phantom union in content, staleness, and +epoch-coherence form (scenario 1); session laundering under the +shipped free-form sessions (scenario 2 — an EXPECTED finding, fixed +only by the demand-graph work); session-checkpoint consistency in +both directions (scenario 2's P6-C cells: the shipped zombie +direction and the rejected resume-clear's amnesia direction, with +checkpoint-consistent sessions green — see finding 0); the +artifact-swap hit-rebind residual hole and the CO-6b-004 binding kill +that closes most of it (scenario 3); warm-drift, overlay placement, +and progress cells (scenarios 5–7); and external principals +(scenario 8's P8 monitor — the `deleteStaleExternalPrincipals` +contract: the non-deleting engine's stale-survivor degrade and the +stale-list recency mutant red, the capable-engine crash/stop/carry +schedules green). Every red regenerates its +counterexample on demand (`p check -tc ` — first find is +seconds-to-minutes); the sweep summaries are archived under +`walker/traces/`. + +## Track B — demand-graph runtime model and the bake-off (P) + +`GRAPH_MODEL_SPEC.md` (v4, frozen after three adversarial rounds) and +the `graph/` P project: frontier scheduler, generations with +quiesce-before-bump and the total mint fence, premise-validated +markers, seal-time sweep with the closure oracle, atomic units, and +the two lineage candidates — eager edges (E) and observable-causal +stamps (S). + +The calibration program found five design bugs before any bake-off +run (GS-CO-001..005 in `graph/CALIBRATION.md`), among them generation +identity reuse across crash re-mints, the carrier-durability fence, +and the retraction catch-up bound; plus two mechanism repairs +(G8B-CAL-1, G9-CAL-1 — stamp compression as first drafted livelocked +honest histories). The frozen matrix is 66 cells clean at 10k +schedules, and the 12-cell bake-off phase matched its declared +verdicts 12/12. + +The bake-off (`graph/BAKEOFF.md`, assembled under the GS-CO-005 +registered decision rule) ties on property satisfaction, and S wins +on mechanism count: no new durable state class, versus E's edge +checkpoint rows, retraction queue, two recovery machineries, and — +decisive in kind, not just count — E's correctness DEPENDENCE on the +constrained session primitives. The calibrated laundering cell +(`tcG2ea_P6G`) shows E sealing a dead writer's value under free-form +sessions with every artifact-level oracle green; S is green under +free-form sessions. Redo work corroborates and does not decide: the +reachable seal-world sets are identical under both variants. + +## Track C — the deductive track (Occult) + +`occult/` (deliverables 6–9), proved in the Occult engine (sibling +repo `../occult`) through the Go host in `occult/host/`: + +- **Laws (D9)**: 15 equational laws of the composition algebra and + stamp lattice proved, 5 negative controls correctly refused + (`occult/LAWS.md`). One law (L1, REPLACES absorption) closes in + bounded form pending an induction tactic. +- **Phantom union, derived**: the broken composition rule + (`occult/src/sync_phantom.occult`) DERIVES the phantom union + deductively — the same bug Track A reaches by search, reached by + proof, from an axiomatization of what the broken algorithm does. +- **Protocol (D8)**: the syncer↔connector source-cache lookup + continuation as a global session term with per-role projections — + 6 projection derivations plus a structural expansion, 4 polarity/ + cap/leg controls refused. The bounce cap is structural (no + five-bounce term exists), mirroring + `sourcecache.MaxLookupBouncesPerRequest`. +- **Trace policies (D7)**: seven ordering/durability policies + (consult-before-replay, clear-before-write, once-per-scope, + publish-before-checkpoint quiescence, seal obligations, + session-checkpoint consistency — finding 0's root cause as a + policy — and external-principal grounding, the + `deleteStaleExternalPrincipals` contract) over a canonical event + vocabulary including attempt + boundaries (`ev_resume`), the delta protocol's delete leg + (`ev_delete`), session operations (`ev_swrite`, + `ev_sread_hit`, `ev_sread_miss`), and the external-principal + phase (`ep_list`, `ep_live`, `ep_recon`, `ep_copy`). Verdict + matrix: 140 cells (20 fixtures × 7 policies), each green fixture + satisfies all, each red violates exactly its own. +- **Reference implementation**: an executable Go prototype of the + demand-graph runtime whose traces are judged by the same oracle; + its legacy mode reproduces the broken behavior and is caught. +- **The bridge to shipped code (D6)**: `pkg/sync` carries a + test-only commit-order recorder (`pkg/sync/sync_trace_audit.go`, + nil in production — the field is only ever assigned from test + files, which are not compiled into non-test binaries). Chaos tests + run the real syncer and export JSONL fixtures; the oracle judges + them: 56 policy cells across cold, warm, crash/resume, + tombstone-delta, record-flip, session-zombie, and + external-principal executions — 54 green plus TWO deliberately red + cells: the session-zombie fixture's `session_ckpt_consistency` + verdict, the standing known-defect pin on the shipped session + semantics (finding 0), and the SQLite external-principal fixture's + `external_principal_grounding` verdict, the standing known-degrade + pin on the non-deleting engine's warn-and-continue resume. + Planted-violation tests prove the bridge detects what it claims + to (`occult/TRACE_BRIDGE.md`). + +## Findings register + +Findings that matter beyond the models themselves: + +0. **Phantom union live in shipped code (real defect, FIXED).** The + walker model's scenario-1 red (the phantom union, tc1c flavor) + was reachable in the shipped 6b syncer via the verdict-flip path: + a warm round cut after its replay copy committed but before its + validator published, upstream moving between attempts, and the + resume's consult missing — the connector's fresh RECORD round + composed with the crashed attempt's copied debris and sealed the + union under the fresh validator, which the next sync validates + clean and replays forward (permanently stale "live" data). + Witnessed by `TestChaosSourceCacheRecordFlipOverReplayDebris`, + fixed by record-round grounding (`groundRecordScope` + + `ClearSourceCacheScope`): a record round is a replacement + listing, so a partition holding rows no completed round published + is cleared before the round's first write. The grounding is + trace-visible ("replacement rounds clear first" — the policy + doctrine, previously structural, now witnessed), and the fix's + mechanism and outcome are both pinned by the witness test. Note + the model's verified V-ATOMIC/V-OVERLAY-UNIT fix family maps onto + a code base with durable marker suppression; the shipped code + heals by re-execution (restart-from-root + idempotent re-copy), + so grounding was the missing piece, not unit-mode commit. + + The adjacent flank is the SESSION STORE — with a CORRECTED + provenance note: an earlier revision of this paragraph claimed + the hazard was found by code reading alone and that "none of the + models contain a session store." That second claim was WRONG. The + walker model has always carried the shipped session semantics + (MStore's `sessionKV`: durable at op commit, survives attempts + and crashes, while the checkpoint token is separate state), and + scenario 2's crash cell (`tc2crash_P6A`, an EXPECTED red since + calibration) contains exactly the zombie mechanism — the re-run + reads the dead attempt's durable stale value. The failure was + dispositional, not model-side: that red was filed as a + future-runtime obligation (sessions variant B, the graph + addendum) instead of being routed as a shipped-code change order, + and the checkpoint-relative ROOT CAUSE — post-crash session state + must equal the restored checkpoint's — was never stated as a + property in any system. Both gaps are now closed mechanically: + + - **P**: the P6-C monitor states the constraint in BOTH + directions. `tc2crash_P6C` reds `P6-C-ZOMBIE` under shipped + semantics (a dead attempt's beyond-checkpoint write observed by + the re-run); `tc2clear_P6C` reds `P6-C-AMNESIA` under the + rejected wholesale resume-clear (a checkpoint-committed value + destroyed — data whose producing work will not re-run); + `tc2consistent_P6C` is green under checkpoint-consistent + sessions, the registered fix. The amnesia premise needed a + reversed root order (cell 21) to be reachable — the writer must + pop before the reader for a committed value to precede a + re-run read. + - **Occult**: trace policy 6 (`session_ckpt_consistency`) states + the same constraint over the canonical vocabulary, with four + fixtures — including the correct-rollback green, where a crash + legally erases an UN-checkpointed write and the re-run's miss + is the fix behaving properly. + - **Witnessed**: `warm_replay_sync_session_zombie.jsonl`, + recorded from a REAL syncer crash/resume execution + (`TestChaosSourceCacheSessionPersistsAcrossResume`, which acts + as the session actor), is judged RED by the oracle — a standing + known-defect pin that flips to green when checkpoint-consistent + sessions land. + + On the code side: a mechanical fix (clearing the namespace on a + participating resume) was shipped and then REVERTED as unsound — + resume never re-runs completed actions, so a wholesale clear + destroys session caches whose producing work will not execute + again (now also a model verdict: `P6-C-AMNESIA`). Current stance + is contractual (CO-6b-009 in the 6b plan): session use must + survive at-least-once re-execution with prior state present, + consults must never be answered from session caches, and session + state is silently partial for replayed scopes — pinned in + `pkg/sourcecache` and `pkg/session/README.md`, with + persistence-across-resume pinned by + `TestChaosSourceCacheSessionPersistsAcrossResume`. The correct + mechanical fence (checkpoint-consistent sessions: a volatile + overlay flushed atomically with the checkpoint) is registered as + future work — and is now the variant the models verify green; + the lineage-bearing fix (session reads as stamped observation + points) is variant-S scope. +1. **Resume re-copy (real code, documentation falsified).** The + resume suite documented that a restored replayed-set skips the + replay copy across a mid-batch cut. The real-trace instrument + shows the skip cannot occur: checkpoints commit at batch + boundaries, so a mid-batch crash always forces a re-copy, and the + actual guard is the copy's replacement idempotence. Comments + corrected in `pkg/sync/chaos_source_cache_resume_test.go`; pinned + in `occult/TRACE_BRIDGE.md`. +2. **E-only laundering (design).** Eager-edge lineage is correct + only with constrained session primitives; free-form reads seal a + dead writer's value undetected. This moved the session-primitive + audit from a correctness gate to an optimization under the + adopted variant S. +3. **Generation identity reuse (design, fixed in spec).** Crash + before checkpoint allowed a re-minted generation to collide with + its predecessor; fixed by the total mint fence (GS-CO-002/003 + family), verified by kill cells. +4. **Stamp compression livelock (design, fixed in spec).** The + first-draft compression rules livelocked honest histories into + the pre-seal pass budget; admissible only with the G9-CAL-1 + minting rules. +5. **Scheduler sensitivity (verification methodology).** The + dying-reader race (`tcG1d_P6G`) needed feedback-PCT and a third + worker to exhibit — implementation tests for that race must not + rely on uniform random schedules. +6. **Engine findings (tooling).** Ground-term evaluation cost grows + ~2x per trace event (the gate for longer real traces), and + parameterized protocol definitions do not project. Recorded with + six other asks in `docs/tasks/occult-engine-changes-brief.md` + (local working doc). + +## What is guaranteed, and what is not + +Three grades of code linkage, in decreasing mechanical strength: + +- **Witnessed** (trace bridge): the policy verdicts hold for the + real executions we exported. This catches what happens; it does + not prove what cannot happen. +- **Calibrated** (both P models, the phantom derivation): the models + reproduce the known bugs, which is evidence of fidelity, not proof + of it. +- **Asserted** (laws ↔ named function contracts, protocol ↔ proto + shapes and Go constants): documented correspondence, held by + review. If the Go side drifts, nothing goes red automatically. + +Standing limits: P verdicts are exhaustive only within the stated +schedule budgets and small-scope configurations (each spec's §8 +declares its exclusions — notably sessions × demand shrink and +session-transitive chains in the graph model). Redo figures are +counts at small scope, not throughput. The models arbitrate designs, +not Go code; the trace bridge is the standing instrument that must +stay current as the design becomes an implementation. + +## What's next + +1. **The variant-S RFC and production implementation** in + `pkg/sync`, carrying the four design consequences listed in + `graph/BAKEOFF.md` (primitives as optimization, observation-point + discipline, compression's minting rules, non-uniform-schedule + race tests). +2. **Keep the oracle current**: as demand-graph code lands, extend + the trace vocabulary with generation stamps and grow fixtures + alongside the implementation — the bridge is only as good as its + coverage. +3. **Occult Ask 8** (tractable ground evaluation) when engine time + exists: it unblocks realistic trace lengths and is the wedge for + the longer-term single-engine unification path. diff --git a/formal/graph/BAKEOFF.md b/formal/graph/BAKEOFF.md new file mode 100644 index 000000000..c6e8eb611 --- /dev/null +++ b/formal/graph/BAKEOFF.md @@ -0,0 +1,151 @@ +# Lineage bake-off verdict: eager edges (E) vs observable-causal stamps (S) + +This is deliverable 4's written recommendation — the artifact the +demand-graph RFC cites. It is assembled under the decision rule +registered in `formal/GRAPH_MODEL_SPEC.md` §12 GS-CO-005 (declared +before the bake-off runs; the rule's v2 text was never committed and +GS-CO-005(a) repairs that provenance), from: + +- the frozen 66-cell calibration matrix (10k schedules per cell, + zero mismatches — `CALIBRATION.md`, freeze sweep 2026-08-30); +- the 12-cell bake-off phase (GS-CO-005(c)/(d) declarations, 12/12 + match — `CALIBRATION.md`, bake-off results); +- the frozen mechanism tally (spec §7.5, amended v3 BEFORE any + bake-off run). + +The decision rule is lexicographic — property satisfaction, then +mechanism count, then redo work — and the first non-tie decides. + +## The candidates + +Both variants ride the same shared chassis (spec §7.5 "shared"): +frontier checkpoint with the admitted-derivation set (death +semantics, admitted-by edges, cursors), generation table with +quiesce-before-bump and the total mint fence, premise-validated +markers (MATCH-only, writer-ineligible), the supersession matrix and +poison rule, the seal-time sweep with the closure oracle, and atomic +units. + +- **Variant E (eager edges)** adds: durable admitted-by edge + checkpoint rows, the resume ∀-pending-purge, derived-support + rebuild plus the agreement check, the retraction rule and queue + with pinned enqueue/drain — and it REQUIRES session variant B + (the three constrained session primitives). +- **Variant S (observable-causal stamps)** adds: stamp merge on + read, the per-output stamp field with the `eAdopt` rewrite, three + observation points (dispatch-time refusal, session-read + read-through with the dead-read count, the pre-seal pass with a + 3-iteration budget), and optional bucketed compression. + +## Axis 1 — property satisfaction: TIE + +Both variants, with their mechanisms on, are GREEN on every honest +cell of the freeze matrix, and every declared kill fires on its +designated monitor (P1-LEGALITY, P-GEN, P-ADOPT, P-MARK, P4-STUCK, +P5-UNDER/OVER, P6-G, SEAL-EXPECT, DEAD-DISPATCH, plus P6-E under E +and P6-S/GPASS under S). Neither variant is eliminated. + +The one structural asymmetry Axis 1 surfaces: **E is correct only +with session variant B.** Under free-form sessions (E+A) the sealed +reader rows embed a dead writer's value with every artifact-level +oracle green — the calibrated laundering find (`tcG2ea_P6G`, the +G2 family's star cell). S is green under free-form sessions +(`tcG2s_All`): stamp merging makes arbitrary reads tracked without +constraining the session surface. Per GS-CO-005(b) this dependency +travels to Axis 2 as part of E's mechanism bill. + +## Axis 2 — mechanism count under the frozen tally: S wins + +The §7.5 counting rule weighs durable state classes over scheduler +rules over per-output overhead. + +- E's bill: one added durable state class (admitted-by edges as + checkpoint rows) plus the retraction queue, two recovery-path + machineries (∀-purge; support rebuild + agreement check), the + retraction rule with its pinned enqueue/drain and the GS-CO-004 + catch-up bound — and the session-B requirement, which is not a + line item but an entire companion surface (three constrained + primitives whose "covers all legitimate uses" claim is a separate + SDK audit obligation). +- S's bill: no new durable state class. Its heaviest item is the + per-output stamp field — the lowest-weight class in the counting + rule — plus merge-on-read and the three observation points as + scheduler rules. Compression is optional (an optimization lever, + not a correctness mechanism). + +First non-tie. **The decision rule terminates here: variant S.** + +## Axis 3 — redo work: corroborates, does not decide + +Citation unblocked by the G5d determination (no divergence; see +below). + +- Metric floor: the zero-crash execution bound is 1 under both + variants (four v1 controls GREEN) — the count oracle measures + crash-caused redo, not variant overhead. +- Worst-case redo across the divergence scripts is SYMMETRIC: + minimal green bound 2 (redo ≤ 1 per node) on the chain, fan-in, + and mutation chassis under both variants; the bound-1 probes red + under both. No chassis separates the variants on redo count. +- Each variant pays the at-least-once cost through its own + mechanism — E's retraction-forced reader re-runs and S's + pass/refusal-forced re-runs both exhibit as REDO-PROBE reds on + their respective legs; where shared machinery forces the redo + (writer-ineligibility), the cost is charged to both equally. +- S-specific costs are bounded and verified: the pre-seal pass + converges within its 3-iteration budget in every honest cell + (GPASS), and stamp compression is admissible only under the + G9-CAL-1 rules (bucket-aligned heal minting + the ambiguity + double-bump), trading bounded extra redo for stamp width. +- G5d (which-is-right): the reachable seal-world sets are IDENTICAL + — {W1, W2} reachable and the sweep-failure world W3 unreachable + under both variants, every reachable world inside the sync-scoped + SealExpect envelope. The variants differ in HOW a world is + reached (E purges the de-demanded child; S refuses its dispatch), + never in WHICH worlds are sealable. + +## Recommendation + +**Adopt variant S — observable-causal stamps over the shared +chassis.** Note that the shared chassis already retains admitted-by +edges and the demand closure for the sweep, so this verdict IS the +hybrid the brief anticipated ("support counting retained solely to +compute the demand closure for the sweep, stamps replacing all eager +retraction") — expressible as shared column + S's adds, which +GS-CO-005(b) admits as a plain variant-S recommendation. + +Design consequences the RFC should carry: + +1. The constrained session primitives demote from correctness + requirement to stamp-width optimization. Free-form session reads + are safe under S (`tcG2s_All`); the primitives remain worth + having to keep stamps narrow, but the SDK audit ("the three + primitives cover all legitimate uses") stops being a correctness + gate. +2. Internal causality gets the same discipline as external: + upstream validators are consulted at observation time, and + stamps apply exactly that observation-point pattern to node + generations (the brief's unification note, now checker-backed). +3. Compression ships only with the G9-CAL-1 minting rules + (re-mints land even, first admissions odd, floor-stale bumps the + owner, parity-ambiguous entries also bump the named node) — + as first drafted it livelocked honest histories into the pass + budget. +4. The quiesce-before-bump pin is shared machinery, but its kill + (`tcG1d_P6G`) needed feedback-PCT and a third worker to exhibit: + implementation tests for the dying-reader race must not rely on + uniform random schedules. + +## Honest limits + +- Small-scope bet as restated in spec §8: sessions × demand shrink + and session-transitive reader-writer chains are excluded by + declaration; first-order retraction and row-transitive support + are exercised. +- Redo figures are checker-verified worst-case COUNTS at small + scope, not throughput; stamp width in bytes is not modeled (G9 + models compression's decision effects, not encodings). +- The model arbitrates the design, not the Go implementation. The + bridge is the trace-policy oracle set (`formal/occult/`, D7) and + the chaos-scenario seam (D6) — keep them current as the RFC turns + into code. diff --git a/formal/graph/CALIBRATION.md b/formal/graph/CALIBRATION.md new file mode 100644 index 000000000..0a72b77ec --- /dev/null +++ b/formal/graph/CALIBRATION.md @@ -0,0 +1,400 @@ +# Graph model calibration — run log + +Status: G1 and G2 families calibrated (30 cells; the 26-cell 10k +gate sweep ran clean and the 4 flap-back/G-pending additions were +calibrated individually — the next full-matrix sweep is the gate +after G3+). FLAP-BACK MACHINERY: the upstream reports CONTENT +epochs everywhere (raw epochs never escape it), so `flapBack` +(raw e>=3 serves content(e1)) keeps validators, manifests, folds, +and SealExpect worlds coherent with no monitor changes. Spec +baseline: +`formal/GRAPH_MODEL_SPEC.md` v4 FROZEN + GS-CO-001..004 (all four +change orders were driven by calibration finds in this build-out; +see §12 of the spec and the "Model decisions of record" section +below). Remaining scenario families (G3–G9, bake-off counts) are +pending — see Pending. + +Toolchain: P 3.1.0 (`p compile` / `p check -tc -s `), +same conventions as `formal/walker/CALIBRATION.md`: verdicts are +audited by counterexample trace-file presence (`tools/sweep.sh`), reds +are the calibration currency, and a green run means nothing except at +the stated budget. + +Project layout mirrors the walker: `PSrc/` (Types, Events, Upstream, +Store, Sched, NodeExec, Env), `PSpec/Monitors.p` (GP1, GP2, GP3prime, +PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6E, GP6S), +`PTst/ScenarioG1.p`. Cell topology 11: parent P (node 0) → consult +node C (node 1). Sessions topology (cell 21, built, exercised from G2 +on): P → writer W/H + reader G. + +## G1 family — phantom-union premises + generation identity (sweep: 10/10 at 5000 schedules) + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tcG1i_All | leg (i): crash sync 2, fetch-fresh policy, e1→e2 between syncs | all core | GREEN | GREEN | 5000 | +| tcG1ii_All | leg (ii): diff unit, crash, e2→e3 between attempts, MATCH-only re-derive fresh | all core | GREEN | GREEN (after GS-CO-002; see finds) | 5000 | +| tcG1iii_E | leg (iii): crash-after-commit, no mutation → ADOPT, lineage E | all core | GREEN | GREEN | 5000 | +| tcG1iii_S | same, lineage S (+P6-S) | all core + P6-S | GREEN | GREEN | 5000 | +| tcG1b_All | two-crash generation-reuse probe, honest | all core | GREEN | GREEN | 5000 | +| tcG1cMut_P3 | adoptOnFail mutant, P3′ control | P3′ | GREEN | GREEN (FAIL consult does not qualify; last qualifying verdict expects the mutant's own rows) | 5000 | +| tcG1cMut_Seal | adoptOnFail mutant, SealExpect control | SealExpect | GREEN | GREEN (GS-CO-002: rows(e2) is inside the sync-scoped envelope — the declared artifact-blindness control) | 5000 | +| tcG1sup_P1 | suppressionOff on the leg-(iii) chassis | P1 | RED | RED: `P1-LEGALITY` (racing double-admission at one generation; second live complete-round copy) | first find | +| tcG1bMut_PGEN | resumeCkptOff | P-GEN | RED | RED: `P-GEN` (re-minted identity carries store commits in two attempts; fireable with ONE crash post-GS-CO-001) | first find | +| tcG1cMut_Adopt | adoptOnFail | P-ADOPT | RED | RED: `P-ADOPT` (adoption after a FAIL consult — MATCH-only eligibility violated) | first find | + +Sweep summary archived at `PCheckerOutput/sweep/summary.txt` (rerun +`tools/sweep.sh` from `formal/graph`). + +## G2 family — session laundering + G1d/G1e probes (topology 21: P -> writer H + reader G) + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tcG2ea_Core | E + variant A, value change across attempts | artifact-level core | GREEN | GREEN | 5000 | +| tcG2ea_P6G | same cell | P6-G | RED | RED: `P6-G` (THE FINDING: no retraction, no stamps — the sealed reader rows embed the dead value; artifact-level monitors all green, the blindness contrast is tcG2ea_Core) | first find | +| tcG2eb_All | E + variant B (retraction + quiesce) | all + P6-G/P6-E | GREEN | GREEN (after GS-CO-003; see finds) | 5000 | +| tcG2ebRetrOff_P6G | retractionOff | P6-G | RED | RED: `P6-G` | first find | +| tcG2s_All | S (stamps + pre-seal pass) | all + P6-G/P6-S | GREEN | GREEN | 5000 | +| tcG2sStampOff_P6G | stampMergeOff | P6-G | RED | RED: `P6-G` | first find | +| tcG2awE_All | announce-window/flap-back honest, E+B, premise-stable | all + P6-E | GREEN | GREEN | 5000 | +| tcG2awS_All | same, S | all + P6-S | GREEN | GREEN | 5000 | +| tcG2awE_Redo | flap-back existence probe | REDO-PROBE | RED | RED: `REDO-PROBE` (the at-least-once cost is real: retraction-forced reader redo exists) | first find | +| tcG2awS_Redo | same, S (pass-forced redo) | REDO-PROBE | RED | RED: `REDO-PROBE` | first find | +| tcG2awWA_E | writerAdopt, E+B | P6-E | RED | RED: `P6-E` (after GS-CO-004; the stranded dead publish is never retracted) | feedback-PCT(20), first find ~3.8k (random first-find sits at the 5k budget edge) | +| tcG2awWA_S | writerAdopt, S | P6-S | RED | RED: `P6-S` (pass budget exhausts against the stranded dead stamp) | first find | +| tcG2eb2c_All | honest two-crash, E+B | all + P6-E | GREEN | GREEN | 5000 | +| tcG1e_PGEN | two crashes + midBumpFenceOff | P-GEN | RED | RED: `P-GEN` (identity reuse; the first-find may ride the first-admission mint path — same toggle per GS-CO-001, same discipline) | first find | +| tcG2fbE_All | WRITER FLAP-BACK probe (R3-F1 second registration), E+B: attempt-1 DIFF publish-bearing unit (d2), crash, content(e3)=content(e1) | all + P6-G/P6-E | GREEN | GREEN (H ineligible -> re-consult vs prev artifact MATCHes -> REPLAY -> body-op re-publishes d1@g2 -> readers cleared; under an elision reading this history strands d2@g1 — the probe is the body-op pin's load-bearing witness) | 5000 | +| tcG2fbS_All | same, S | all + P6-S | GREEN | GREEN | 5000 | +| tcG2fbE_Redo | flap-back chassis | REDO-PROBE | RED | RED: `REDO-PROBE` (declared expected count >= 1) | first find | +| tcG2ebPend_Redo | honest E+B laundering chassis | REDO-PROBE | RED | RED: `REDO-PROBE` (the G-pending re-retraction clause fires: R2-M6(i) via GS-CO-004's catch-up + re-publish paths) | first find | +| tcG1dProbe_Redo | G1d chassis | REDO-PROBE | RED | RED: `REDO-PROBE` (the race arms: forced reader redo exists) | first find | +| tcG1d_P6G | E+B + quiesceOff, 3 workers | P6-G | RED | RED: `P6-G` (dying reader's stale round survives to seal; confirmed post-handshake — the first feedback-PCT run instead caught the harness deadlock below) | feedback-PCT(20), first find at 188 schedules | + +### G1D-REACH — reachability ladder for the quiesceOff kill + +The dying-reader race is DEEP under uniform random search: 165k +random schedules found nothing. Bisected by temporary existence +probes, each RED = milestone reached: forced reader redo on the +chassis (`tcG1dProbe_Redo`, kept, first find ~3k); same-node +concurrent dispatch (temp diag, common); a second reader round +CLEARING while another is open on the reader's key (temp diag, +reached under 30k); the full kill — the stale round's content +surviving to SEAL — never, at 120k random. Two aids resolved it, +both harness-level: + +1. `nWorkers = 3` for this cell (spec §1 tagged note) so the + retraction-forced re-run dispatches AT the bump instead of + waiting for a completion carrier to free a worker (with 2, the + race additionally needs the scheduler to starve the dying worker + through H's entire completion). +2. Strategy: `--sch-feedbackpct 20` (feedback-mutating PCT). + First find at 188 schedules, 0.53% buggy — the race is + priority-inversion-shaped, exactly PCT's regime; the sweep runs + this cell under that strategy (per-cell strategy column in + `tools/sweep.sh`). + +Diagnostics removed after resolution; the redo probe stays as a +sweep cell (the ladder's first rung documents the chassis arming). + +### Harness find — crash-arm queue race (feedback-PCT bycatch) + +The first feedback-PCT sweep run of `tcG1d_P6G` redded on DEADLOCK, +not P6-G: the env sends `eCrashArm` right after creating the +attempt scheduler, so a schedule that starves the env lets the +ENTIRE attempt (through seal) enter the store's queue ahead of the +arm — the store's at-seal resolution point sees `armed == false`, +seals clean, and the late-landing arm never resolves; the env +blocks on `eCrashAck` forever. Random search never starves one +machine for hundreds of steps, which is why no random sweep (graph +or walker) ever hit it; priority-based PCT does exactly that and +found it at 34 schedules. Fix: synchronous arm handshake +(`eCrashArm` → `eCrashArmed`) BEFORE the attempt is created, so the +arm's queue position precedes every attempt op by construction. +The walker env has the same latent race (arm sent after +`new MSyncAttempt`, random-only sweeps) — noted in the walker's +calibration log; harness-level, no bearing on either model's +verdicts. + +## G5 family — sweep, purge, and the closure oracle (topology 24: paginated P -> consult C, named on page 1 only) + +Cell 24 scripts UPSTREAM DEMAND SHRINK: the parent's own scope (key +0) mutates between attempts, and its page-1 row — the only row that +names C — is the row the e1->e2 mutation deletes. New monitors: GP5 +(artifact demand-closure, both directions, self-contained over the +sealed artifact: CLOSED = every non-root sealed partition has a +living namer, COMPLETE = every named child's partition is sealed), +PURGEPROBE (existence probe on `eAnnPurge`, REDO-PROBE pattern), +GDEADDISPATCH (the G5e count oracle in checkable form: no node ever +dispatches with every admitted-by edge dead), GPASS (§10.8: honest S +cells seal within the pass budget; also asserted retroactively in +tcG1iii_S / tcG2s_All / tcG2awS_All / tcG2fbS_All). + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tcG5aE_All | honest sweep, E, shrink chassis | all core + GP5 + DEAD-DISPATCH | GREEN | GREEN (which parent world seals is schedule-dependent under sync-scoped freshness: P re-ran -> seal {0}; P completed at e1 -> C live, seal {0,1} — C's key EXCLUDED from the attempt-2 expectation, the structural question is GP5's) | 10000 | +| tcG5aS_All | same, S (dispatch-refusal leg) | + GPASS | GREEN | GREEN | 10000 | +| tcG5f_All | honest, NO shrink (R2-F5 no-starvation witness) | all core + GP5 | GREEN | GREEN (resume purges C through the mid-round window; P's live re-derivation re-names it; the purged hash is re-admissible; C re-runs — starvation would red SealExpect) | 10000 | +| tcG5bE_P5 | sweepOff, E | P5 (CLOSED) | RED | RED: `P5-UNDER` (C's dead partition seals with no living namer) | first find | +| tcG5bS_P5 | sweepOff, S | P5 (CLOSED) | RED | RED: `P5-UNDER` | first find | +| tcG5c_P5 | sweepOverreach, no shrink | P5 (COMPLETE) | RED | RED: `P5-OVER` (an in-closure key dropped at seal; the sealed parent still names it) | first find | +| tcG5e_Probe | honest E shrink chassis | PURGE-PROBE | RED | RED: `PURGE-PROBE` (the resume ∀-purge fires — the counterexample exhibits the mid-round C-pending & P-pending checkpoint window) | first find | +| tcG5e_PurgeOff | purgeOff, E | DEAD-DISPATCH | RED | RED: `DEAD-DISPATCH` (the restored C dispatches with its only admitted-by edge dead — dead demand executed) | first find | +| tcG5f_Drop | demandDrop, no shrink | SealExpect / P5 (COMPLETE) | RED | RED: `SEAL-EXPECT` (the dropped child never runs; the expected demand-closure key is missing) | first find | + +### G5 build finds (model-level, no spec change) + +1. **Per-announce demand timing implemented** (G-RULE-1 TIMING PIN). + The G1/G2 build derived demand at the completion carrier only — + observationally equivalent for those families, but the pin is + load-bearing here: the mid-round checkpoint window (C-pending ∧ + parent-pending) that the resume ∀-purge exists for is UNREACHABLE + under carrier-only derivation (exactly round-1 F5(iii)'s + argument). A paginated record round now sends the scheduler a + demand note per committed child-naming page (`eGDemandNote`, + read-note pattern); each note is its own carrier under GS-CO-003's + one-delta fence. The completion carrier still re-derives + (idempotent via G-RULE-2 suppression + edge dedupe) — belt and + braces, and a crashed note costs nothing (the row is durable; a + pending parent re-derives, a completed parent's admissions rode + the fence). +2. **Pass domain = demand closure** (S). The pre-seal pass chased + dead stamps on OUT-OF-CLOSURE keys — debris the sweep is about to + drop — force-bumping their owners into dispatch-refusal loops + until the budget exhausted on an honest history (tcG5aS_All red + before the fix). The scan now skips keys outside the current + closure, recomputed per sealPhase entry. Spec §5's pass text + ("one scan over a drained frontier") does not state the domain; + flagged for an RFC-stage clarification line, not a change order. +3. **demandDrop models a lost PATHWAY, not a lost message.** With + belt-and-braces derivation the original drop-one-admission inject + is always healed by the second derivation of the same emission + (tcG5f_Drop was green). The inject now drops every admission of + the first hash it fires on. +4. **The count oracle is a dispatch-time announce.** "No post-resume + C execution" is not directly assertable (C's post-resume run is + HONEST when the completed parent's naming stays live — + sync-scoped freshness again); the invariant form is + DEAD-DISPATCH: no node dispatches while every admitted-by edge + names a dead generation. Honest mechanisms (E resume purge, S + dispatch refusal) make it unreachable on every cell, so it is + asserted in the honest G5 greens, not just the kill. + +## G3 / G4 / G6-G9 — built and calibrated + +G4 (duplicate admission) is REGISTERED COVERAGE, not new cells: cell +11's parent names C on EVERY row — the double-token fan-in premise — +so the honest suppression leg IS tcG1i_All and the `suppressionOff` +kill IS tcG1sup_P1 (round-1's walk shape: racing double admission, +P1-LEGALITY). G8a (record REPLACES over dead debris) is likewise G1 +sweep coverage: the crash cells explore every mid-record-round +position and the REPLACES clear wipes debris on re-run. + +New machinery for the remaining families (all announce-only): + +- G3 (cell 25): scripted GRACEFUL STOP (interrupt 1) — the flagged + consult execution stops after its consult announce, the scheduler + checkpoints with the node pending at its cursor, the attempt ends + unsealed with the store intact; `eGSwapPrev` rebinds the PREV + artifact between attempts. nWorkers=1 (no straggler commits). +- G6 (cells 26 chain / 28 fan-in): GEXECBOUND count oracle — + executions per node per sync <= cfg.execBound; minimal GREEN bound + = checker-verified worst case; bound-minus-one RED probes are the + redo existence exhibits (adequacy §10.1 count-oracle kills). + Declared bounds: 2 everywhere (redo <= 1 per node). +- G7 (cell 27): loud deterministic failure (failNode/failSync) with + a GENERATION-BLIND fingerprint (F11); env abandon ladder (give up + after 2 identical fingerprints); GP4STUCK reds 3 in a row. + tcG7_Ladder GREEN / tcG7_Stuck RED declared. +- G8b: `composeDead` on the overlay unit (skip clear + prev-copy). + DECLARED FINDING (pre-run analysis): the mutant is + CONTENT-INVISIBLE in this envelope — with 2 row ids and truthful + TOTAL diffs, every diff from the debris's base overwrites/removes + every debris id. [SUPERSEDED by G8B-CAL-1: content-invisibility + confirmed, but the crash re-run leg is mechanism-visible to P1 — + see calibration results. tcG8bMut_P1 is the kill; tcG8bMut_Ctl + keeps the content oracles GREEN.] +- G8c (cell 29): keyOf maps two distinct derivations to one output + key; the poison path (already store-side: void + adopt-refusal + + SealExpect exclusion + P1 exemption) gets a POISONPROBE existence + probe. GP5 is NOT asserted (its key = hash - 1 convention is what + this cell breaks). +- G8d: marker flap-back (cell 11 + flapBack + interrupt 3 + + between-attempt mutation): honest GREEN via R3-M1's REPLAY-verdict + correction; `markerCleanupOff` -> P-MARK RED declared. +- G9: `stampCompression` — the S pass compares FLOOR-BUCKETED stamps + (buckets of 2): stale-erring, never false-live. Safety verdicts + must be identical to uncompressed legs (any change refutes + admissibility). [Convergence rules and the growth-exhibit pair as + first declared were wrong — see find G9-CAL-1 in the calibration + results.] + +Deferred to the bake-off phase: G6's v1 control scripts (delta ~ 0 +calibration points; metric-only, no kill) and the G5d cross-variant +seal-artifact meta-analysis (harness-level, outside P; §10.6). + +### Calibration results (10k schedules per cell; 28 cells, all +### matching declared verdicts after the finds below) + +Kills, first pass: 7/8 red cells fired under uniform random search — +tcG7_Stuck [P4-STUCK], tcG8c_Poison [POISON-PROBE], and the +count-oracle probes tcG6{a,c}{E,S}_Redo + tcG9c_Redo [EXEC-BOUND]. + +**Find G8D-CAL (search depth, not model).** tcG8dMut_PMARK was 0/10k +under uniform search. The kill needs attempt 1's crash to land in the +[replay-unit commit, completion checkpoint) window — the LAST store +ops of the attempt — and `maybeCrash`'s per-op coin makes P(crash at +op k) = 2^-k: late crash positions decay geometrically, ~1e-4 before +attempt-2 requirements compound it. Same pathology as G1D-REACH; +same remedy: `--sch-feedbackpct=20` finds P-MARK reliably (0.02% +buggy schedules at 20k), pinned for the cell in sweep.sh. Trace +confirms the declared shape: the marker survives attempt 2's REPLACES +clear (mutant), and P-MARK fires on the foreign round mutating the +marked key's partition. + +Honest legs, first pass: 13/17 GREEN; the four reds decomposed into +one harness gap and two genuine finds: + +- Harness gap (not a find): cell 27 was missing from the env's + SealExpect expectation script (key 1 unexpected on an honest + sync-1 seal). One-line fix; tcG7_Ladder GREEN. +- **Find G8B-CAL-1 — the composeDead mutant is content-invisible + but NOT mechanism-invisible.** The declared vacuity (pre-run + analysis, logged below) only considered the no-crash leg. On the + crash re-run the skipped clear leaves the DEAD attempt's copy + round live under the composed diff, and P1's + one-live-replacement-copy legality reds it — the §4b precondition + has a kill after all. Disposition: tcG8bMut_P1 is the kill + [P1-LEGALITY]; tcG8bMut_Ctl now asserts only the content-level + oracles (GP2/GP3'/SealExpect/GP5) and stays GREEN as the + registered content-invisibility evidence. +- **Find G9-CAL-1 — floor-bucketed stamp comparison is admissible + ONLY WITH bucket-aligned heal minting and an ambiguity + double-bump.** As first built (compressed comparison only, all + mints +1), honest S histories redded PASS-BUDGET: every heal + re-created odd generations one level down — the pass's owner bump + left readers merging the writer's unchanged odd generation, and + dispatch-refusal re-admissions re-minted children odd — so + convergence needs O(demand-depth) iterations, not 3. The + admissible rule set, now implemented and green: (i) every + scheduler RE-mint (pass heal, retraction, resume, refusal + re-admission) lands on an even generation; first-admission mints + stay odd, so the mixed-parity stamp population and its redo cost + remain modeled; (ii) a floor-stale entry always bumps the key's + OWNER (the exact rule), and when the entry is parity-AMBIGUOUS + (floor(s) = cur-1, cur odd, named node != owner) it ALSO bumps + the NAMED node — the owner's re-read alone can never prove an + odd live generation. Worst case converges in exactly the budget + (detect/heal, raced-merge re-heal, verify). Exhibit reshaped: a + crash script MASKS the redo growth (resume redo and heal-wave + redo both peak at 2 per node), so the growth pair is the + no-crash fan-in chassis — tcG9cBase_All (uncompressed) + GREEN@bound1, tcG9c_All GREEN@bound2, tcG9c_Redo RED@bound1. + +## Model decisions of record (already registered as spec change orders) + +- GS-CO-001 — MINT-FENCE TOTALITY. First honest run of the leg-(iii) + cell redded P-GEN: attempt 1 crashed before any checkpoint, + attempt 2 cold-restarted and re-minted (P, 1), whose identity + carried commits in both attempts. G-RULE-3's durable fence is + total over all four minting paths: attempt-start root mint and + first-admission mid-attempt mint (found here), resume bump (F4), + mid-attempt bump (R3-F2). Encoded as forced checkpoints before + first dispatch of any newly minted generation; the root-mint fence + rides `resumeCkptOff`, the first-admission fence rides + `midBumpFenceOff`. +- GS-CO-003 — CARRIER-DURABILITY ATOMICITY. First honest G2 run + redded SealExpect (closure key missing): P's carrier admitted H + (fence ckpt), crashed before G's fence — restore shows P + COMPLETED with G's admission lost, and a completed parent never + re-derives, so the demand starves. A carrier's derived effects + (admissions, mints, edges) commit durably as ONE delta at the end + of the demand loop; no checkpoint may separate a carrier's + completion from its admissions. +- GS-CO-004 — RETRACTION CATCH-UP BOUND. Two coupled finds: (a) + carrier-time session-read registration makes the R2-F1 + dying-reader race structurally unreachable (the scheduler can + never see an in-flight reader), so reads register at READ time + via a scheduler note; (b) an unbounded registration-side + retraction rule livelocks the writerAdopt strand (the adopted + writer never re-publishes; the reader re-runs forever; the + frontier never drains; P6-E is structurally unevaluable and the + kill cell goes GREEN-by-divergence). Registration-side retraction + is a once-per-(reader, dead-wgen) CATCH-UP; all repeated + retraction is re-publish-driven, per R2-M6(i) as written. +- GS-CO-002 — SYNC-SCOPED SEALEXPECT + P-ADOPT (find G1-CAL-1). The + scripted single-epoch expectation redded an honest leg-(ii) + schedule: C's diff round completed AND checkpointed in attempt 1, + crash landed before seal, attempt 2 restored an all-completed + frontier and sealed attempt-1 content (e2) while the expectation + demanded attempt-2's live world (e3). That survival is licensed by + G-RULE-2 (completed-across-crash) and the SYNC-scoped staleness + contract, so SealExpect now accumulates the acceptable epoch set + across attempt starts. Consequence: the `adoptOnFail` laundering + (FAIL-consult adoption of e2) is inside the envelope — invisible + to EVERY artifact-level oracle (SealExpect and P3′ both green on + the mutant, kept as declared controls) — so the kill moved to the + new P-ADOPT mechanism monitor: adoption requires a validated MATCH + consult announced by the adopting (node, generation) BEFORE the + adopt commits. The announce-order pin matters: the first build + announced the justifying consult after the store's adopt announce + and P-ADOPT redded three honest adopt cells; the justification + precedes the act. + +## Freeze sweep — 2026-08-30, PASSED + +Full matrix, 66 cells at 10k schedules each (tools/sweep.sh, one +build: the G9-CAL-1 Sched + cell-27 expectation fix + G8b test +split): 66/66 match declared verdicts, zero mismatches. Every kill +fired on its designated monitor (P1-LEGALITY, P-GEN, P-ADOPT, +P-MARK, P4-STUCK, P5-UNDER/OVER, P6-G/E/S, SEAL-EXPECT, EXEC-BOUND, +REDO-PROBE, PURGE-PROBE, POISON-PROBE, DEAD-DISPATCH); every honest +leg is clean. Three cells carry the pinned `--sch-feedbackpct=20` +strategy (tcG1d_P6G, tcG2awWA_E, tcG8dMut_PMARK — deep-crash-window +reach, G1D-REACH/G8D-CAL). The graph model is CALIBRATED and FROZEN. + +## Bake-off phase — declarations (GS-CO-005, registered BEFORE run) + +The protocol, the restated decision rule, and the provenance repair +(the v2 §10.6/§10.7 text was never committed) are in the spec's §12 +GS-CO-005 entry. Cells and declared verdicts: + +| cell | config | property | declared | +|---|---|---|---| +| tcG6aE_Ctl | cell 26 chain, E, NO crash, execBound 1 | honest stack + EXEC-BOUND | GREEN (zero-crash redo floor is zero) | +| tcG6aS_Ctl | same, S (+GPASS) | honest stack + EXEC-BOUND | GREEN | +| tcG6cE_Ctl | cell 28 fan-in, E, NO crash, execBound 1 | honest stack + EXEC-BOUND | GREEN | +| tcG6cS_Ctl | same, S (+GPASS) | honest stack + EXEC-BOUND | GREEN | +| tcG6bE_Redo | G6b mutation chassis, E, execBound 1 | EXEC-BOUND | RED (mutation-chassis redo exists) | +| tcG6bS_Redo | same, S | EXEC-BOUND | RED | +| tcG5dE_W1 | G5a shrink chassis, E, target {0→2} | SEAL-WORLD | RED (world reachable) | +| tcG5dS_W1 | same, S | SEAL-WORLD | RED | +| tcG5dE_W2 | target {0→1, 1→1} | SEAL-WORLD | RED (completed-across-crash world) | +| tcG5dS_W2 | same, S | SEAL-WORLD | RED | +| tcG5dE_W3 | target {0→2, 1→1} | SEAL-WORLD | GREEN (sweep-failure world unreachable) | +| tcG5dS_W3 | same, S | SEAL-WORLD | GREEN | + +Any variant-asymmetric outcome (a leg deviating from its declared +verdict under exactly one variant) is a divergence finding and +blocks Axis-3 citation until dispositioned (GS-CO-005(d)). + +### Bake-off results — 2026-08-30, 12/12 match declarations + +10k schedules per cell, uniform random, one run (summary archived at +`PCheckerOutput/bakeoff/summary.txt`). All four v1 controls GREEN +(the zero-crash redo floor is bound 1 under BOTH variants — the +count oracle measures crash-caused redo, not variant overhead); both +G6b bound-1 probes RED on EXEC-BOUND (the mutation chassis's redo is +real and symmetric); all four reachable-world probes RED on +SEAL-WORLD and both W3 probes GREEN under both variants. + +G5d WHICH-IS-RIGHT DETERMINATION: the reachable seal-world sets are +IDENTICAL across variants — {W1, W2} reachable, W3 unreachable — +and every reachable world lies inside the sync-scoped SealExpect +envelope (asserted by the honest G5a greens). No divergence finding; +Axis-3 citation is unblocked. Where the two variants differ is HOW +a world is reached (E purges C / S refuses C's dispatch on the W1 +path), never WHICH worlds are sealable. + +## Pending +- Nothing. The verdict document is `BAKEOFF.md` (assembled under + GS-CO-005's registered decision rule). diff --git a/formal/graph/PCheckerOutput/bakeoff/summary.txt b/formal/graph/PCheckerOutput/bakeoff/summary.txt new file mode 100644 index 000000000..13af1e9b8 --- /dev/null +++ b/formal/graph/PCheckerOutput/bakeoff/summary.txt @@ -0,0 +1,12 @@ +tcG6aE_Ctl expected=GREEN observed=GREEN ok +tcG6aS_Ctl expected=GREEN observed=GREEN ok +tcG6cE_Ctl expected=GREEN observed=GREEN ok +tcG6cS_Ctl expected=GREEN observed=GREEN ok +tcG6bE_Redo expected=RED observed=RED ok +tcG6bS_Redo expected=RED observed=RED ok +tcG5dE_W1 expected=RED observed=RED ok +tcG5dS_W1 expected=RED observed=RED ok +tcG5dE_W2 expected=RED observed=RED ok +tcG5dS_W2 expected=RED observed=RED ok +tcG5dE_W3 expected=GREEN observed=GREEN ok +tcG5dS_W3 expected=GREEN observed=GREEN ok diff --git a/formal/graph/PCheckerOutput/sweep/summary.txt b/formal/graph/PCheckerOutput/sweep/summary.txt new file mode 100644 index 000000000..04a1779a5 --- /dev/null +++ b/formal/graph/PCheckerOutput/sweep/summary.txt @@ -0,0 +1,67 @@ +tcG1i_All expected=GREEN observed=GREEN ok +tcG1ii_All expected=GREEN observed=GREEN ok +tcG1iii_E expected=GREEN observed=GREEN ok +tcG1iii_S expected=GREEN observed=GREEN ok +tcG1b_All expected=GREEN observed=GREEN ok +tcG1cMut_P3 expected=GREEN observed=GREEN ok +tcG1cMut_Seal expected=GREEN observed=GREEN ok +tcG1sup_P1 expected=RED observed=RED ok [P1-LEGALITY] +tcG1bMut_PGEN expected=RED observed=RED ok [P-GEN] +tcG1cMut_Adopt expected=RED observed=RED ok [P-ADOPT] +tcG2ea_Core expected=GREEN observed=GREEN ok +tcG2eb_All expected=GREEN observed=GREEN ok +tcG2s_All expected=GREEN observed=GREEN ok +tcG2awE_All expected=GREEN observed=GREEN ok +tcG2awS_All expected=GREEN observed=GREEN ok +tcG2eb2c_All expected=GREEN observed=GREEN ok +tcG2fbE_All expected=GREEN observed=GREEN ok +tcG2fbS_All expected=GREEN observed=GREEN ok +tcG2ea_P6G expected=RED observed=RED ok [P6-G] +tcG2ebRetrOff_P6G expected=RED observed=RED ok [P6-G] +tcG2sStampOff_P6G expected=RED observed=RED ok [P6-G] +tcG2awE_Redo expected=RED observed=RED ok [REDO-PROBE] +tcG2awS_Redo expected=RED observed=RED ok [REDO-PROBE] +tcG2fbE_Redo expected=RED observed=RED ok [REDO-PROBE] +tcG2ebPend_Redo expected=RED observed=RED ok [REDO-PROBE] +tcG2awWA_E expected=RED observed=RED ok [liveness,P6-E] +tcG2awWA_S expected=RED observed=RED ok [P6-S] +tcG1dProbe_Redo expected=RED observed=RED ok [REDO-PROBE] +tcG1d_P6G expected=RED observed=RED ok [P6-G] +tcG1e_PGEN expected=RED observed=RED ok [P-GEN] +tcG5aE_All expected=GREEN observed=GREEN ok +tcG5aS_All expected=GREEN observed=GREEN ok +tcG5f_All expected=GREEN observed=GREEN ok +tcG5bE_P5 expected=RED observed=RED ok [P5-UNDER] +tcG5bS_P5 expected=RED observed=RED ok [P5-UNDER] +tcG5c_P5 expected=RED observed=RED ok [P5-OVER] +tcG5e_Probe expected=RED observed=RED ok [PURGE-PROBE] +tcG5e_PurgeOff expected=RED observed=RED ok [DEAD-DISPATCH] +tcG5f_Drop expected=RED observed=RED ok [SEAL-EXPECT] +tcG3_E expected=GREEN observed=GREEN ok +tcG3_S expected=GREEN observed=GREEN ok +tcG6aE_All expected=GREEN observed=GREEN ok +tcG6aS_All expected=GREEN observed=GREEN ok +tcG6bE_All expected=GREEN observed=GREEN ok +tcG6bS_All expected=GREEN observed=GREEN ok +tcG6cE_All expected=GREEN observed=GREEN ok +tcG6cS_All expected=GREEN observed=GREEN ok +tcG6aE_Redo expected=RED observed=RED ok [EXEC-BOUND] +tcG6aS_Redo expected=RED observed=RED ok [EXEC-BOUND] +tcG6cE_Redo expected=RED observed=RED ok [EXEC-BOUND] +tcG6cS_Redo expected=RED observed=RED ok [EXEC-BOUND] +tcG7_Ladder expected=GREEN observed=GREEN ok +tcG7_Stuck expected=RED observed=RED ok [P4-STUCK] +tcG8b_All expected=GREEN observed=GREEN ok +tcG8bMut_Ctl expected=GREEN observed=GREEN ok +tcG8bMut_P1 expected=RED observed=RED ok [P1-LEGALITY] +tcG8c_All expected=GREEN observed=GREEN ok +tcG8c_Poison expected=RED observed=RED ok [POISON-PROBE] +tcG8d_All expected=GREEN observed=GREEN ok +tcG8dMut_PMARK expected=RED observed=RED ok [P-MARK] +tcG9s_All expected=GREEN observed=GREEN ok +tcG9awS_All expected=GREEN observed=GREEN ok +tcG9G5aS_All expected=GREEN observed=GREEN ok +tcG9cBase_All expected=GREEN observed=GREEN ok +tcG9c_All expected=GREEN observed=GREEN ok +tcG9c_Redo expected=RED observed=RED ok [EXEC-BOUND] +SWEEP-DONE cells=66 mismatches=0 diff --git a/formal/graph/PSpec/Monitors.p b/formal/graph/PSpec/Monitors.p new file mode 100644 index 000000000..a1b55fd6e --- /dev/null +++ b/formal/graph/PSpec/Monitors.p @@ -0,0 +1,764 @@ +/* Property monitors (SPEC 7). Announce-subscribed; ghost fields are + labels of decisions the model already made. Fold and legality + implement the walker round-5 F1 pin with SPEC 4d generation + grounding: a round completes at the commit of its last prescribed + op; a generation's COMPLETE round stays in fold and count until + ADOPTED (contribution transfers) or SUPERSEDED, and the + supersession removal is DEATH-GATED (a live-rows removal reading + would dissolve the walker cell-4 alarm — the suppressionOff racing + red lives on exactly this gate). Poisoned keys are legality- and + content-EXEMPT (the poison is the alarm; the scope is + seal-excluded by SealExpect). */ + +type tGRound = (key: int, verdict: tGVerdict, consultEpoch: int, vBase: int, hasCopy: bool, completed: bool, node: int, gen: int); + +// Partition key content as id -> epoch (ghost content tag). +fun contentOfG(part: tGPart, key: int): map[int, int] { + var out: map[int, int]; + var ids: seq[int]; + var i: int; + if (!(key in part)) { return out; } + ids = keys(part[key]); + i = 0; + while (i < sizeof(ids)) { + out[ids[i]] = part[key][ids[i]].epoch; + i = i + 1; + } + return out; +} + +spec GP1 observes eAnnSyncStart, eAnnClear, eAnnReplayCopy, eAnnUpsert, eAnnTombstones, eAnnPublish, eAnnMarkerPut, eAnnAdopt, eAnnGenBump, eAnnPoison, eAnnGSeal { + var rounds: map[int, tGRound]; + var foldEpoch: map[int, int]; // key -> folded content epoch + var copyRounds: map[int, seq[int]]; // key -> LIVE copy-contributing roundIds + var latestGen: map[int, int]; // node -> latest generation seen + var poisonedK: map[int, bool]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + rounds = default(map[int, tGRound]); + foldEpoch = default(map[int, int]); + copyRounds = default(map[int, seq[int]]); + latestGen = default(map[int, int]); + poisonedK = default(map[int, bool]); + } + on eAnnGenBump do (p: (syncN: int, node: int, newGen: int, reason: int)) { + bumpLatest(p.node, p.newGen); + } + on eAnnPoison do (p: (syncN: int, key: int)) { + poisonedK[p.key] = true; + } + on eAnnMarkerPut do (p: (syncN: int, key: int, node: int, gen: int, roundId: int, pubBearing: bool, contentEpoch: int, ghost: tGGhost)) { + trackOp(p.key, p.ghost, false, -1); + } + on eAnnClear do (p: (syncN: int, key: int, ghost: tGGhost)) { + var live: seq[int]; + var i: int; + var r: tGRound; + trackOp(p.key, p.ghost, false, -1); + // SPEC 4d supersession removal, DEATH-GATED: the clear + // removes the copy contribution of DEAD complete rounds + // only; a live round's contribution stays (and a second + // completed copy then trips legality). + if (p.key in copyRounds) { + i = 0; + while (i < sizeof(copyRounds[p.key])) { + r = rounds[copyRounds[p.key][i]]; + if (r.node in latestGen && r.gen < latestGen[r.node]) { + live = copyRounds[p.key]; + live -= i; + copyRounds[p.key] = live; + } else { + i = i + 1; + } + } + } + } + on eAnnReplayCopy do (p: (syncN: int, key: int, vBase: int, rows: seq[tGRow], ghost: tGGhost)) { + trackOp(p.key, p.ghost, true, p.vBase); + } + on eAnnUpsert do (p: (syncN: int, key: int, rows: seq[tGRow], ghost: tGGhost)) { + trackOp(p.key, p.ghost, false, -1); + } + on eAnnTombstones do (p: (syncN: int, key: int, removes: seq[int], ghost: tGGhost)) { + trackOp(p.key, p.ghost, false, -1); + } + on eAnnPublish do (p: (syncN: int, key: int, v: int, ghost: tGGhost)) { + // Attestation-only at publish (walker parity): truthful + // validators are epoch-valued. + assert p.v == p.ghost.consultEpoch, "P1-ATTEST-PUBLISH: published validator epoch differs from the round's verdict epoch"; + trackOp(p.key, p.ghost, false, -1); + } + on eAnnAdopt do (p: (syncN: int, key: int, node: int, fromGen: int, toGen: int, adoptedRoundId: int, rows: seq[tGRow], ghost: tGGhost)) { + var r: tGRound; + bumpLatest(p.ghost.node, p.ghost.gen); + // Contribution TRANSFER (SPEC 4a/4d): the adopted round is + // re-grounded at the adopting generation; fold and count + // are unchanged. + if (p.adoptedRoundId in rounds) { + r = rounds[p.adoptedRoundId]; + r.gen = p.toGen; + rounds[p.adoptedRoundId] = r; + } + } + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var ks: seq[int]; + var i: int; + var k: int; + var have: map[int, int]; + ks = keys(p.partition); + i = 0; + while (i < sizeof(ks)) { + k = ks[i]; + if (!(k in poisonedK) && sizeof(p.partition[k]) > 0) { + have = contentOfG(p.partition, k); + if (k in foldEpoch) { + assert have == rowsAt(foldEpoch[k]), "P1-CONTENT: sealed partition diverges from the round-log fold"; + if (k in p.manifest) { + assert p.manifest[k] == foldEpoch[k], "P1-ATTEST-SEAL: manifest entry epoch differs from the fold epoch"; + } + } else { + assert false, "P1-CONTENT: incomplete-round debris sealed"; + } + } + i = i + 1; + } + // A manifest entry over an empty fold attests a + // composition the round log does not contain (walker + // round-7 F3 pin). + ks = keys(p.manifest); + i = 0; + while (i < sizeof(ks)) { + if (!(ks[i] in poisonedK)) { + assert ks[i] in foldEpoch, "P1-ATTEST-EMPTY: manifest entry published over an empty fold"; + } + i = i + 1; + } + } + } + + fun bumpLatest(node: int, gen: int) { + if (!(node in latestGen) || gen > latestGen[node]) { + latestGen[node] = gen; + } + } + + fun trackOp(key: int, ghost: tGGhost, isCopy: bool, vBase: int) { + var info: tGRound; + var cr: seq[int]; + bumpLatest(ghost.node, ghost.gen); + if (ghost.roundId in rounds) { + info = rounds[ghost.roundId]; + } else { + info = (key = key, verdict = ghost.verdict, consultEpoch = ghost.consultEpoch, vBase = -1, hasCopy = false, completed = false, node = ghost.node, gen = ghost.gen); + } + info.consultEpoch = ghost.consultEpoch; + if (isCopy) { + info.hasCopy = true; + info.vBase = vBase; + } + if (ghost.lastOp) { + info.completed = true; + } + rounds[ghost.roundId] = info; + if (ghost.lastOp) { + // Round completion IS the fold order. Replacement counting + // happens HERE: committed copies within COMPLETE rounds + // only (walker round-7 F2 pin), over LIVE contributions + // only (SPEC 4d grounding). + if (info.hasCopy) { + if (key in copyRounds) { cr = copyRounds[key]; } + cr += (sizeof(cr), ghost.roundId); + copyRounds[key] = cr; + if (!(key in poisonedK)) { + assert sizeof(copyRounds[key]) <= 1, "P1-LEGALITY: second live complete-round replacement copy for one key in one sync"; + } + } + if (ghost.verdict == GV_REPLAY) { + if (info.hasCopy) { + foldEpoch[key] = info.vBase; + } + } else if (ghost.verdict != GV_ADOPT) { + foldEpoch[key] = ghost.consultEpoch; + } + } + } +} + +spec GP2 observes eAnnScenarioInit, eAnnSyncStart, eAnnConsult, eAnnPoison, eAnnGSeal { + var bound: int; + var consulted: map[int, bool]; + var poisonedK: map[int, bool]; + + start state Monitoring { + on eAnnScenarioInit do (p: (maxStaleness: int)) { + bound = p.maxStaleness; + } + on eAnnSyncStart do (p: (syncN: int)) { + consulted = default(map[int, bool]); + poisonedK = default(map[int, bool]); + } + on eAnnPoison do (p: (syncN: int, key: int)) { + poisonedK[p.key] = true; + } + on eAnnConsult do (p: (syncN: int, key: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int, node: int, gen: int)) { + // Consulted-against-upstream (walker pin): validation + // match, fresh fetch, or CHANGED-WITH-DIFF verdict. The + // adopting MATCH qualifies (MATCH-only eligibility makes + // the freshness claim true, SPEC 4a). + if (p.validated || p.freshFetch || p.diffVerdict) { + consulted[p.key] = true; + } + } + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var ks: seq[int]; + var ids: seq[int]; + var i: int; + var j: int; + var k: int; + ks = keys(p.partition); + i = 0; + while (i < sizeof(ks)) { + k = ks[i]; + if (!(k in poisonedK) && sizeof(p.partition[k]) > 0) { + assert k in consulted, "P2-CONSULT: sealed key not consulted against upstream this sync"; + ids = keys(p.partition[k]); + j = 0; + while (j < sizeof(ids)) { + assert p.partition[k][ids[j]].hops <= bound, "P2-STALENESS: row replay-travel exceeds the scenario bound"; + j = j + 1; + } + } + i = i + 1; + } + } + } +} + +spec GP3prime observes eAnnSyncStart, eAnnConsult, eAnnPoison, eAnnGSeal { + var lastEpoch: map[int, int]; // key -> epoch of last qualifying consult + var poisonedK: map[int, bool]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + lastEpoch = default(map[int, int]); + poisonedK = default(map[int, bool]); + } + on eAnnPoison do (p: (syncN: int, key: int)) { + poisonedK[p.key] = true; + } + on eAnnConsult do (p: (syncN: int, key: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int, node: int, gen: int)) { + if (p.validated || p.freshFetch || p.diffVerdict) { + lastEpoch[p.key] = p.epoch; + } + } + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var ks: seq[int]; + var i: int; + var k: int; + ks = keys(p.partition); + i = 0; + while (i < sizeof(ks)) { + k = ks[i]; + if (k in lastEpoch && !(k in poisonedK) && sizeof(p.partition[k]) > 0) { + assert contentOfG(p.partition, k) == rowsAt(lastEpoch[k]), "P3'-COHERENCE: sealed content epoch differs from last consulted verdict epoch"; + } + i = i + 1; + } + } + } +} + +// P-GEN (G-RULE-3 / R2-N3): no two attempts contain store-commit +// announces attributed to the same (node, generation); adoption +// re-announces attribute to the ADOPTER. Scoped per sync (the +// generation table is per-sync scheduling state). +spec PGEN observes eAnnSyncStart, eAnnClear, eAnnReplayCopy, eAnnUpsert, eAnnTombstones, eAnnPublish, eAnnMarkerPut, eAnnAdopt, eAnnSessionSet { + var attemptOf: map[int, int]; // node*1000 + gen -> attempt + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + attemptOf = default(map[int, int]); + } + on eAnnClear do (p: (syncN: int, key: int, ghost: tGGhost)) { check(p.ghost); } + on eAnnReplayCopy do (p: (syncN: int, key: int, vBase: int, rows: seq[tGRow], ghost: tGGhost)) { check(p.ghost); } + on eAnnUpsert do (p: (syncN: int, key: int, rows: seq[tGRow], ghost: tGGhost)) { check(p.ghost); } + on eAnnTombstones do (p: (syncN: int, key: int, removes: seq[int], ghost: tGGhost)) { check(p.ghost); } + on eAnnPublish do (p: (syncN: int, key: int, v: int, ghost: tGGhost)) { check(p.ghost); } + on eAnnMarkerPut do (p: (syncN: int, key: int, node: int, gen: int, roundId: int, pubBearing: bool, contentEpoch: int, ghost: tGGhost)) { check(p.ghost); } + on eAnnAdopt do (p: (syncN: int, key: int, node: int, fromGen: int, toGen: int, adoptedRoundId: int, rows: seq[tGRow], ghost: tGGhost)) { check(p.ghost); } + on eAnnSessionSet do (p: (syncN: int, skey: int, val: int, writer: int, wgen: int, ghost: tGGhost)) { check(p.ghost); } + } + + fun check(g: tGGhost) { + var gk: int; + gk = g.node * 1000 + g.gen; + if (gk in attemptOf) { + assert attemptOf[gk] == g.attempt, "P-GEN: store-commit announces attributed to one (node, generation) in two attempts (identity reuse)"; + } else { + attemptOf[gk] = g.attempt; + } + } +} + +// P-MARK (R2-F4): a marker present for a key ⟹ the key's partition +// equals the marked round's committed outputs. Checkable form: no +// FOREIGN store op mutates a marked key's partition — every legal +// transition rides an op that first rebinds or removes the marker +// (unit put overwrites first; REPLACES clear deletes first; poison +// voids; adoption rebinds). +spec PMARK observes eAnnSyncStart, eAnnMarkerPut, eAnnMarkerDel, eAnnAdopt, eAnnPoison, eAnnClear, eAnnReplayCopy, eAnnUpsert, eAnnTombstones { + var markedRound: map[int, int]; // key -> marking roundId + var voidedK: map[int, bool]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + markedRound = default(map[int, int]); + voidedK = default(map[int, bool]); + } + on eAnnMarkerPut do (p: (syncN: int, key: int, node: int, gen: int, roundId: int, pubBearing: bool, contentEpoch: int, ghost: tGGhost)) { + markedRound[p.key] = p.roundId; + if (p.key in voidedK) { voidedK -= p.key; } + } + on eAnnMarkerDel do (p: (syncN: int, key: int)) { + if (p.key in markedRound) { markedRound -= p.key; } + } + on eAnnAdopt do (p: (syncN: int, key: int, node: int, fromGen: int, toGen: int, adoptedRoundId: int, rows: seq[tGRow], ghost: tGGhost)) { + markedRound[p.key] = p.ghost.roundId; + } + on eAnnPoison do (p: (syncN: int, key: int)) { + voidedK[p.key] = true; + } + on eAnnClear do (p: (syncN: int, key: int, ghost: tGGhost)) { check(p.key, p.ghost); } + on eAnnReplayCopy do (p: (syncN: int, key: int, vBase: int, rows: seq[tGRow], ghost: tGGhost)) { check(p.key, p.ghost); } + on eAnnUpsert do (p: (syncN: int, key: int, rows: seq[tGRow], ghost: tGGhost)) { check(p.key, p.ghost); } + on eAnnTombstones do (p: (syncN: int, key: int, removes: seq[int], ghost: tGGhost)) { check(p.key, p.ghost); } + } + + fun check(key: int, g: tGGhost) { + if (key in markedRound && !(key in voidedK)) { + assert markedRound[key] == g.roundId, "P-MARK: a foreign round mutated a marked key's partition (marker no longer describes the partition)"; + } + } +} + +// SealExpect: the scripted closure + content oracle (SPEC 7 closure +// oracle / SPEC 9 SealExpect discipline). The env announces the +// expected sealed key set and per-key LIVE content epoch at EVERY +// attempt start; the monitor accumulates the sync's acceptable +// epoch SET per key. Sealed content must match SOME attempt-start +// epoch of this sync — the artifact freshness contract is +// SYNC-scoped (staleness bound 1), and a key whose derivation +// completed and checkpointed before a crash legitimately seals the +// earlier attempt's world (completed-across-crash, G-RULE-2; +// calibration find G1-CAL-1). Closure is exact both directions. +// Poisoned/excluded keys are exempt. +spec SealExpectG observes eAnnSyncStart, eAnnExpectSeal, eAnnPoison, eAnnGSeal { + var active: bool; + var expSync: int; + var acc: map[int, seq[int]]; + var excluded: map[int, bool]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + if (active && p.syncN != expSync) { active = false; } + } + on eAnnExpectSeal do (p: (syncN: int, exp: map[int, int], excluded: map[int, bool])) { + var ks: seq[int]; + var es: seq[int]; + var i: int; + if (!active || expSync != p.syncN) { + acc = default(map[int, seq[int]]); + excluded = default(map[int, bool]); + } + active = true; + expSync = p.syncN; + ks = keys(p.exp); + i = 0; + while (i < sizeof(ks)) { + es = default(seq[int]); + if (ks[i] in acc) { es = acc[ks[i]]; } + if (!inIntSeq(es, p.exp[ks[i]])) { + es += (sizeof(es), p.exp[ks[i]]); + } + acc[ks[i]] = es; + i = i + 1; + } + ks = keys(p.excluded); + i = 0; + while (i < sizeof(ks)) { + excluded[ks[i]] = true; + i = i + 1; + } + } + on eAnnPoison do (p: (syncN: int, key: int)) { + excluded[p.key] = true; + } + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var ks: seq[int]; + var i: int; + var j: int; + var k: int; + var anyMatch: bool; + var have: map[int, int]; + if (!active || p.syncN != expSync) { return; } + ks = keys(acc); + i = 0; + while (i < sizeof(ks)) { + k = ks[i]; + if (!(k in excluded)) { + assert k in p.partition && sizeof(p.partition[k]) > 0, "SEAL-EXPECT: expected demand-closure key missing from the sealed artifact"; + have = contentOfG(p.partition, k); + anyMatch = false; + j = 0; + while (j < sizeof(acc[k])) { + if (have == rowsAt(acc[k][j])) { anyMatch = true; } + j = j + 1; + } + assert anyMatch, "SEAL-EXPECT: sealed content matches no attempt-start world of this sync"; + } + i = i + 1; + } + ks = keys(p.partition); + i = 0; + while (i < sizeof(ks)) { + k = ks[i]; + if (!(k in excluded) && sizeof(p.partition[k]) > 0) { + assert k in acc, "SEAL-EXPECT: sealed key outside the scripted demand closure"; + } + i = i + 1; + } + active = false; + } + } +} + +// P-ADOPT (adopt legality, R2-F2 MATCH-only eligibility): every +// adoption must be justified by a prior validated MATCH consult by +// the same (node, generation) — adoption and its consult always +// share one execution. A FAIL-consult followed by adoption is the +// G1c laundering mutant: it smuggles a stale world past the seal +// inside the sync-scoped freshness envelope, so no artifact-level +// oracle can see it; the mechanism monitor is the kill. +spec PADOPT observes eAnnSyncStart, eAnnConsult, eAnnAdopt { + var matched: map[int, bool]; // node*1000+gen -> validated MATCH seen + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + matched = default(map[int, bool]); + } + on eAnnConsult do (p: (syncN: int, key: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int, node: int, gen: int)) { + if (p.hit && p.validated) { + matched[p.node * 1000 + p.gen] = true; + } + } + on eAnnAdopt do (p: (syncN: int, key: int, node: int, fromGen: int, toGen: int, adoptedRoundId: int, rows: seq[tGRow], ghost: tGGhost)) { + assert (p.ghost.node * 1000 + p.ghost.gen) in matched, "P-ADOPT: adoption without a validated MATCH consult by the adopting generation (MATCH-only eligibility violated)"; + } + } +} + +// P6-G (laundering oracle, all legs; SPEC 7): at seal, every row +// derived THIS SYNC (hops 0) embedding a real session value must +// embed the FINAL session value — comparison by VALUE, so same-value +// re-derivation is green (R2-F6). Mechanism-independent. +spec GP6G observes eAnnSyncStart, eAnnSessionSet, eAnnGSeal { + var sess: map[int, int]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + sess = default(map[int, int]); + } + on eAnnSessionSet do (p: (syncN: int, skey: int, val: int, writer: int, wgen: int, ghost: tGGhost)) { + sess[p.skey] = p.val; + } + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var ks: seq[int]; + var ids: seq[int]; + var i: int; + var j: int; + var k: int; + var r: tGRow; + ks = keys(p.partition); + i = 0; + while (i < sizeof(ks)) { + k = ks[i]; + ids = keys(p.partition[k]); + j = 0; + while (j < sizeof(ids)) { + r = p.partition[k][ids[j]]; + if (r.sVal >= 0 && r.hops == 0) { + assert 0 in sess && sess[0] == r.sVal, "P6-G: sealed row embeds a session value differing from the final derived value (laundered dead read)"; + } + j = j + 1; + } + i = i + 1; + } + } + } +} + +// P6-E (mechanism conformance, E+B; SPEC 7): retraction liveness — +// every reader execution of a value whose writer generation is dead +// at seal re-ran (a later read by the same reader exists). Asserted +// only in E+B cells. +spec GP6E observes eAnnSyncStart, eAnnSessionRead, eAnnGSeal { + var reads: seq[tReadRec]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + reads = default(seq[tReadRec]); + } + on eAnnSessionRead do (p: (syncN: int, reader: int, rgen: int, skey: int, found: bool, val: int, writer: int, wgen: int)) { + if (p.found) { + reads += (sizeof(reads), (reader = p.reader, rgen = p.rgen, skey = p.skey, val = p.val, writer = p.writer, wgen = p.wgen)); + } + } + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var i: int; + var j: int; + var later: bool; + i = 0; + while (i < sizeof(reads)) { + if (reads[i].writer in p.genTable && reads[i].wgen < p.genTable[reads[i].writer]) { + later = false; + j = 0; + while (j < sizeof(reads)) { + if (reads[j].reader == reads[i].reader && reads[j].rgen > reads[i].rgen) { + later = true; + } + j = j + 1; + } + assert later, "P6-E: a reader execution of a dead session value never re-ran before seal (retraction liveness)"; + } + i = i + 1; + } + } + } +} + +// REDO-PROBE (existence probe, walker C1-probe pattern): asserts NO +// forced re-admission (retraction- or observation-forced) ever +// happens. Asserted in cells DECLARING an expected forced-redo count +// >= 1; RED is the pass verdict — the counterexample is the exhibit +// that the mechanism pays its at-least-once cost (R2-F6: the count +// is a metric, never a property; this probe is how a metric claim +// becomes checkable without asserting it on every schedule). +spec REDOPROBE observes eAnnReadmit { + start state Monitoring { + on eAnnReadmit do (p: (syncN: int, node: int, hash: int, gen: int, reason: int)) { + assert p.reason == 1, "REDO-PROBE: a forced redo occurred (existence exhibit, not a failure)"; + } + } +} + +// P5 (artifact demand-closure, both directions, at seal — the G5 +// family's subject). Self-contained over the sealed artifact itself, +// no environment counterfactual (which attempt's parent world +// survives a crash is schedule-dependent under sync-scoped +// freshness): +// CLOSED (P5-UNDER kill): every non-root sealed key is named by +// some sealed row's childHash — under-sweep debris has no living +// namer. +// COMPLETE (P5-OVER / demand-drop kill): every childHash named by +// a sealed row has a non-empty sealed partition — an overreaching +// sweep or a dropped admission strands a named child. +// Identity conventions: hash = node id + 1, key = node id. +spec GP5 observes eAnnGSeal { + start state Monitoring { + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var named: map[int, bool]; + var ks: seq[int]; + var ids: seq[int]; + var r: tGRow; + var i: int; + var j: int; + ks = keys(p.partition); + i = 0; + while (i < sizeof(ks)) { + ids = keys(p.partition[ks[i]]); + j = 0; + while (j < sizeof(ids)) { + r = p.partition[ks[i]][ids[j]]; + if (r.childHash > 0) { named[r.childHash] = true; } + j = j + 1; + } + i = i + 1; + } + i = 0; + while (i < sizeof(ks)) { + if (ks[i] != 0 && sizeof(p.partition[ks[i]]) > 0) { + assert (ks[i] + 1) in named, "P5-UNDER: sealed artifact contains a partition no sealed row names (un-swept debris)"; + } + i = i + 1; + } + ks = keys(named); + i = 0; + while (i < sizeof(ks)) { + assert (ks[i] - 1) in p.partition && sizeof(p.partition[ks[i] - 1]) > 0, "P5-OVER: a sealed row names a child whose partition is missing (overreach or dropped demand)"; + i = i + 1; + } + } + } +} + +// PURGE-PROBE (existence probe, REDO-PROBE pattern): asserts the +// resume-time ∀-purge NEVER fires; RED is the pass verdict — the +// counterexample exhibits the mid-round checkpoint window +// (C-pending & parent-pending) that only per-announce demand timing +// (G-RULE-1 TIMING PIN) makes reachable. +spec PURGEPROBE observes eAnnPurge { + start state Monitoring { + on eAnnPurge do (p: (syncN: int, node: int, hash: int)) { + assert false, "PURGE-PROBE: a resume purge occurred (existence exhibit, not a failure)"; + } + } +} + +// DEAD-DISPATCH (the G5e count oracle in checkable form): no node is +// EVER dispatched while every admitted-by edge names a dead +// generation. Honest mechanisms make this unreachable (E purges at +// resume, S refuses at dispatch); purgeOff executes dead demand. +spec GDEADDISPATCH observes eAnnDeadDispatch { + start state Monitoring { + on eAnnDeadDispatch do (p: (syncN: int, node: int, hash: int)) { + assert false, "DEAD-DISPATCH: a dead-demand node was dispatched (purge/refusal failed)"; + } + } +} + +// PASS-BUDGET (§10.8): the pre-seal pass converges within its budget +// in every honest S cell — a budget-exhausted honest seal is a +// finding, not noise. Kill cells that RELY on exhaustion (writerAdopt +// S) do not assert it. +spec GPASS observes eAnnBudgetExhausted { + start state Monitoring { + on eAnnBudgetExhausted do (p: (syncN: int)) { + assert false, "PASS-BUDGET: the pre-seal pass exhausted its budget on an honest history"; + } + } +} + +// EXEC-BOUND (G6 bake-off count oracle): executions per node per +// sync never exceed the cell's declared bound (announced by the env +// from cfg at scenario init; 0 = unmonitored). The minimal GREEN +// bound is the checker-verified worst-case count for the leg; the +// bound-minus-one RED probe is the existence exhibit that the redo +// is real (adequacy §10.1: count-oracle kills). +spec GEXECBOUND observes eAnnScenarioInit, eAnnExecBound, eAnnSyncStart, eAnnExec { + var bound: int; + var counts: map[int, int]; + + start state Monitoring { + on eAnnScenarioInit do (p: (maxStaleness: int)) { bound = 0; } + on eAnnExecBound do (p: (bound: int)) { bound = p.bound; } + on eAnnSyncStart do (p: (syncN: int)) { counts = default(map[int, int]); } + on eAnnExec do (p: (syncN: int, attempt: int, node: int, gen: int)) { + if (bound <= 0) { return; } + if (p.node in counts) { + counts[p.node] = counts[p.node] + 1; + } else { + counts[p.node] = 1; + } + assert counts[p.node] <= bound, "EXEC-BOUND: a node exceeded the cell's per-sync execution bound"; + } + } +} + +// POISON-PROBE (existence probe, REDO-PROBE pattern): asserts the +// same-key distinct-derivation poison NEVER fires; RED is the pass +// verdict on the G8c chassis (both derivations always commit). +spec POISONPROBE observes eAnnPoison { + start state Monitoring { + on eAnnPoison do (p: (syncN: int, key: int)) { + assert false, "POISON-PROBE: the same-key poison fired (existence exhibit, not a failure)"; + } + } +} + +// P4-STUCK (G7, walker P4 analog): three consecutive attempt +// failures with an identical generation-blind fingerprint and no +// abandon is a stuck sync (attempt budget 3, SPEC 8). The abandon +// ladder gives up after 2, so the honest leg never reaches 3. +spec GP4STUCK observes eAnnSyncStart, eAnnAttemptFail { + var lastFp: int; + var streak: int; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { lastFp = -1; streak = 0; } + on eAnnAttemptFail do (p: (syncN: int, attempt: int, node: int, fingerprint: int)) { + if (p.fingerprint == lastFp) { + streak = streak + 1; + } else { + lastFp = p.fingerprint; + streak = 1; + } + assert streak < 3, "P4-STUCK: three identical-fingerprint attempt failures without an abandon"; + } + } +} + +// P6-S (mechanism conformance, S; SPEC 7, at-seal form only, R2-F6): +// no sealed output carries a dead-generation stamp. Red MEANS the +// mechanism failed (a dead stamp survived the pre-seal pass). +// Asserted only in S cells. +spec GP6S observes eAnnGSeal { + start state Monitoring { + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var ks: seq[int]; + var ns: seq[int]; + var i: int; + var j: int; + ks = keys(p.stamps); + i = 0; + while (i < sizeof(ks)) { + if (ks[i] in p.partition && sizeof(p.partition[ks[i]]) > 0) { + ns = keys(p.stamps[ks[i]]); + j = 0; + while (j < sizeof(ns)) { + assert !(ns[j] in p.genTable) || p.stamps[ks[i]][ns[j]] >= p.genTable[ns[j]], "P6-S: sealed output carries a dead-generation stamp (the pass failed or exhausted its budget)"; + j = j + 1; + } + } + i = i + 1; + } + } + } +} + +// SEAL-WORLD (GS-CO-005(d) existence probe, REDO-PROBE pattern): the +// G5d cross-variant seal-world meta-analysis. The env announces a +// target world (manifest restricted to keys sealing non-empty +// partitions) for the interrupted sync; the probe asserts that world +// is NEVER sealed — RED is the pass verdict on reachable-world +// probes, GREEN on the declared-unreachable sweep-failure world. +// Asserted alone in tcG5d* cells; the honest G5a greens carry the +// SealExpect envelope this probe's reachable worlds must sit inside. +spec GSEALWORLD observes eAnnSealWorld, eAnnGSeal { + var target: map[int, int]; + var targetSync: int; + var armed: bool; + + start state Monitoring { + on eAnnSealWorld do (p: (syncN: int, exp: map[int, int])) { + target = p.exp; + targetSync = p.syncN; + armed = true; + } + on eAnnGSeal do (p: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int])) { + var world: map[int, int]; + var ks: seq[int]; + var i: int; + if (!armed || p.syncN != targetSync) { return; } + ks = keys(p.manifest); + i = 0; + while (i < sizeof(ks)) { + if (ks[i] in p.partition && sizeof(p.partition[ks[i]]) > 0) { + world[ks[i]] = p.manifest[ks[i]]; + } + i = i + 1; + } + assert !(world == target), "SEAL-WORLD: the target sealed world was reached"; + } + } +} diff --git a/formal/graph/PSrc/Env.p b/formal/graph/PSrc/Env.p new file mode 100644 index 000000000..263d92645 --- /dev/null +++ b/formal/graph/PSrc/Env.p @@ -0,0 +1,239 @@ +/* MGEnv: the per-scenario test driver (SPEC 3, walker parity). Owns + the sync chain, attempt lifecycle, crash scripting (armed + injection; timing genuinely explored), between-attempt/between-sync + upstream mutation, and the SealExpect counterfactual (the scripted + closure + content expectation, announced from live upstream state + at each attempt start — the env-side independent oracle base). */ + +machine MGEnv { + var store: machine; + var upstream: machine; + var cfg: tGCfg; + var crash1Used: bool; + var crash2Used: bool; + + start state Run { + entry (c: tGCfg) { + var syncN: int; + var attempt: int; + var agen: int; + var ck: tGCkpt; + var hasCk: bool; + var sched: machine; + var syncDone: bool; + var crashedThisAttempt: bool; + var sealedSeen: bool; + var failCount: int; + var attemptFailed: bool; + cfg = c; + announce eAnnScenarioInit, (maxStaleness = 1,); + if (cfg.execBound > 0) { + announce eAnnExecBound, (bound = cfg.execBound,); + } + if (sizeof(cfg.sealWorld) > 0) { + announce eAnnSealWorld, (syncN = cfg.interruptSync, exp = cfg.sealWorld); + } + store = new MGStore(); + upstream = new MGUpstream((flapBack = cfg.flapBack,)); + syncN = 1; + while (syncN <= cfg.nSyncs) { + send store, eGReset, (client = this, syncN = syncN); + receive { case eStoreAck: {} } + announce eAnnSyncStart, (syncN = syncN,); + attempt = 1; + syncDone = false; + failCount = 0; + while (!syncDone) { + assert attempt <= 3, "attempt budget exceeded (SPEC 8)"; + agen = syncN * 10 + attempt; + hasCk = false; + if (attempt > 1) { + send store, eGReadCkptReq, (client = this,); + receive { + case eGReadCkptResp: (r: (ck: tGCkpt, has: bool)) { + ck = r.ck; + hasCk = r.has; + } + } + } + announceExpectation(syncN); + // Arm-and-confirm BEFORE creating the attempt: an + // arm racing the attempt can land after the seal, + // never resolve, and deadlock this machine (the + // store's at-seal resolution point only sees arms + // queued ahead of the seal). + crashedThisAttempt = false; + if (syncN == cfg.interruptSync) { + if ((cfg.interrupt == 2 || cfg.interrupt == 3) && attempt == 1 && !crash1Used) { + crash1Used = true; + crashedThisAttempt = true; + } + if (cfg.interrupt == 3 && attempt == 2 && !crash2Used) { + crash2Used = true; + crashedThisAttempt = true; + } + if (crashedThisAttempt) { + send store, eCrashArm, (client = this, agen = agen); + receive { case eCrashArmed: {} } + } + } + sched = new MGraphSched((env = this, store = store, upstream = upstream, agen = agen, syncN = syncN, attempt = attempt, cfg = cfg, ck = ck, has = hasCk)); + if (crashedThisAttempt) { + receive { case eCrashAck: {} } + send store, eReadSealedReq, (client = this,); + sealedSeen = false; + receive { + case eReadSealedResp: (r: (sealed: bool)) { + sealedSeen = r.sealed; + } + } + if (sealedSeen) { + // The attempt sealed before the crash + // landed; consume its end report. + receive { case eGAttemptEnded: (r: (sealed: bool, failed: bool)) {} } + syncDone = true; + } else { + betweenAttempts(); + attempt = attempt + 1; + } + } else { + attemptFailed = false; + receive { + case eGAttemptEnded: (r: (sealed: bool, failed: bool)) { + sealedSeen = r.sealed; + attemptFailed = r.failed; + } + } + if (attemptFailed) { + // Loud failure (G7): the abandon ladder + // gives up after 2 identical fingerprints + // (the fail script is deterministic, so + // consecutive fingerprints are identical + // by construction); without it the retry + // loop re-fails until P4-STUCK fires. + failCount = failCount + 1; + if (cfg.ladder && failCount >= 2) { + announce eAnnAbandon, (syncN = syncN,); + syncDone = true; + } else { + betweenAttempts(); + attempt = attempt + 1; + } + } else if (cfg.interrupt == 1 && syncN == cfg.interruptSync && attempt == 1) { + // Scripted graceful stop (G3): the flagged + // consult always fires before any seal. + assert !sealedSeen, "stop-scripted attempt sealed"; + betweenAttempts(); + attempt = attempt + 1; + } else { + assert sealedSeen, "attempt ended unsealed without a crash script"; + syncDone = true; + } + } + } + if (cfg.mutateBetweenSyncs && syncN == 1) { + mutateUpstream(mutKey()); + } + syncN = syncN + 1; + } + goto FinishedEnv; + } + } + + state FinishedEnv { + ignore eGAttemptEnded, eCrashAck, eCrashArmed; + } + + // The mutation target: the consult node's scope (cell 11), the + // writer's scope (cell 21), or the PARENT's own scope (cell 24 — + // the G5 demand-shrink family mutates what the parent derives + // demand FROM). + fun mutKey(): int { + if (cfg.cell == 21) { return 2; } + if (cfg.cell == 24) { return 0; } + return 1; + } + + fun betweenAttempts() { + if (cfg.mutateBetweenAttempts) { + mutateUpstream(mutKey()); + } + if (cfg.cell == 25) { + // G3: swap the PREV artifact for C's key to sibling + // content between attempts (epoch 9 never validates). + send store, eGSwapPrev, (client = this, key = 1, epoch = 9); + receive { case eStoreAck: {} } + } + } + + fun mutateUpstream(k: int) { + send upstream, eMutate, (client = this, scope = k); + receive { case eMutateAck: {} } + } + + // SealExpect counterfactual (SPEC 7/9): the expected sealed key + // set is the cell's demand closure; the expected content per key + // is rows at the key's LIVE upstream epoch, read (never executed) + // at attempt start. Later attempts overwrite the expectation, so + // the check always binds the sealing attempt's world. + fun announceExpectation(syncN: int) { + var exp: map[int, int]; + var excluded: map[int, bool]; + exp[0] = epochOf(0); + if (cfg.cell == 11 || cfg.cell == 25 || cfg.cell == 27) { + exp[1] = epochOf(1); + } + if (cfg.cell == 21) { + exp[2] = epochOf(2); + exp[3] = epochOf(3); + } + if (cfg.cell == 24) { + // C is demanded only while P's row 1 exists (epoch 1). + // After the shrink C's key is EXCLUDED, not merely + // unexpected: whether it seals depends on which attempt's + // parent world survives (sync-scoped freshness) — the + // structural question belongs to GP5's artifact closure, + // not the counterfactual. + if (epochOf(0) <= 1) { + exp[1] = epochOf(1); + } else { + excluded[1] = true; + } + } + if (cfg.cell == 26) { + // Chain P -> S1 -> C -> GC; the C/GC tail is demanded + // only while S1's row 1 exists (G6b's shrink excludes it, + // same sync-scoped reasoning as cell 24). + exp[1] = epochOf(1); + if (epochOf(1) <= 1) { + exp[4] = epochOf(4); + exp[5] = epochOf(5); + } else { + excluded[4] = true; + excluded[5] = true; + } + } + if (cfg.cell == 28) { + exp[1] = epochOf(1); + exp[4] = epochOf(4); + exp[5] = epochOf(5); + } + if (cfg.cell == 29) { + // Key 1 is poisoned on every schedule (two distinct + // derivations both commit it); eAnnPoison excludes it in + // the monitor — the expectation still names it so a + // MISSING poison (defense failure) surfaces. + exp[1] = epochOf(1); + } + announce eAnnExpectSeal, (syncN = syncN, exp = exp, excluded = excluded); + } + + fun epochOf(k: int): int { + var e: int; + send upstream, eValidateReq, (client = this, scope = k, v = -1); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { e = r.epoch; } + } + return e; + } +} diff --git a/formal/graph/PSrc/Events.p b/formal/graph/PSrc/Events.p new file mode 100644 index 000000000..2cb2c0274 --- /dev/null +++ b/formal/graph/PSrc/Events.p @@ -0,0 +1,165 @@ +/* Events. Store ops are request/ack; every attempt-owned request + carries agen (attempt id) and the crash protocol drops ops from + dead attempts (walker parity: dropped ops are never acked; the + eStoreDead response lets receivers park instead of blocking). */ + +// ---- store ops (worker/scheduler -> MGStore) ---- +event eGReset: (client: machine, syncN: int); +event eGLookupReq: (client: machine, agen: int, key: int); +event eGLookupResp: (hit: bool, v: int); +event eGMarkerReadReq: (client: machine, agen: int, key: int); +event eGMarkerReadResp: (present: bool, marker: tMarker); +// delMarker: the REPLACES clear deletes the key's marker (SPEC 3 +// clear-placement pin; markerCleanupOff removes exactly this). +event eGClearScope: (client: machine, agen: int, key: int, delMarker: bool, ghost: tGGhost); +event eGUpsertPage: (client: machine, agen: int, key: int, rows: seq[tGRow], ghost: tGGhost); +event eGPublishEntry: (client: machine, agen: int, key: int, v: int, stamp: map[int, int], hash: int, ghost: tGGhost); +// V-ATOMIC replay unit (settled hand-off, MODEL_SPEC 9.6): clear + +// copy + marker + publish as ONE atomic store op. Marker announce +// FIRST among constituents (P-MARK convention: every legal partition +// mutation rides an op that first (re)binds the marker). +event eGReplayUnit: (client: machine, agen: int, key: int, v: int, marker: tMarker, stamp: map[int, int], hash: int, ghost: tGGhost); +// V-OVERLAY-UNIT: clear + copy(base) + overlay pages + marker + +// publish(V_to) as ONE atomic store op. +event eGOverlayUnit: (client: machine, agen: int, key: int, v: int, upserts: seq[tGRow], removes: seq[int], marker: tMarker, stamp: map[int, int], hash: int, composeDead: bool, ghost: tGGhost); +// Unit commit response: the key's final rows (copied rows can name +// children, so the carrier report needs them for demand derivation). +event eGUnitResp: (rows: seq[tGRow]); +// Premise-validated adoption (SPEC 4a): one atomic op. Store-side +// preconditions (R2-N1 + R3-M2): fromGen dead per the last durable +// generation table AND the key not poisoned; allowLiveFrom is the +// suppressionOff deviation (declared, R2-N1). Response carries the +// adopted rows for the re-announce (demand re-derivation). +event eGAdoptReq: (client: machine, agen: int, key: int, node: int, fromGen: int, toGen: int, roundId: int, allowLiveFrom: bool, ghost: tGGhost); +event eGAdoptResp: (ok: bool, rows: seq[tGRow]); +// Session ops (SPEC 3 MSessionStore; body ops per the R3-F1 pin). +event eGSessionPub: (client: machine, agen: int, skey: int, val: int, writer: int, wgen: int, ghost: tGGhost); +event eGSessionGetReq: (client: machine, agen: int, reader: int, rgen: int, skey: int); +event eGSessionGetResp: (found: bool, val: int, writer: int, wgen: int); +event eGCheckpointReq: (client: machine, agen: int, ck: tGCkpt, forced: bool); +event eGReadCkptReq: (client: machine); +event eGReadCkptResp: (ck: tGCkpt, has: bool); +event eGReadRowsReq: (client: machine, agen: int, key: int); +event eGReadRowsResp: (rows: seq[tGRow], present: bool); +event eGReadStampsReq: (client: machine, agen: int); +event eGReadStampsResp: (stamps: map[int, map[int, int]], owners: map[int, int]); +// Seal: keep = the final demand closure keys (sweep drops the rest; +// doSweep false = sweepOff). genTable rides the seal for P6-S. +event eGSealReq: (client: machine, agen: int, keep: seq[int], doSweep: bool, genTable: map[int, int]); +event eReadSealedReq: (client: machine); +event eReadSealedResp: (sealed: bool); +event eStoreAck; +event eStoreDead; +event eCrashArm: (client: machine, agen: int); +// Synchronous arm handshake: the store confirms the arm BEFORE the +// env creates the attempt, so the arm can never lose the queue race +// to the entire attempt (an unresolved arm deadlocks the env — found +// by feedback-PCT on the G1d cell; latent in the walker too). +event eCrashArmed; +event eCrashAck; + +// ---- upstream (synchronous request/response; walker parity) ---- +event eValidateReq: (client: machine, scope: int, v: int); +event eValidateResp: (ok: bool, epoch: int); +event eFetchReq: (client: machine, scope: int, page: int); +event eFetchResp: (rows: seq[tGRow], epoch: int, morePages: bool); +event eDiffReq: (client: machine, scope: int, fromEpoch: int, page: int); +event eDiffResp: (upserts: seq[tGRow], removes: seq[int], epoch: int, morePages: bool); +event eMutate: (client: machine, scope: int); +event eMutateAck; + +// ---- scheduler <-> worker ---- +event eGDispatch: (pend: tPendingNode, execId: int, attempt: int, stop: bool); +// Scripted graceful stop (G3, walker case 3): the flagged execution +// stops AFTER its consult announce, before any round commit; the +// scheduler checkpoints (the stopped node stays pending at its +// cursor) and ends the attempt unsealed with the store intact. +event eGStopReq: (node: int, gen: int); +// Between-attempt previous-artifact swap (G3): the env rebinds the +// PREV manifest + partition for one key to sibling content, so the +// resumed consult validates against the actually-current base. +event eGSwapPrev: (client: machine, key: int, epoch: int); +// Loud attempt failure (G7, walker P4 analog): the scripted node +// fails at execution start; the fingerprint is GENERATION-BLIND +// (round-1 F11: a fingerprint that hashes the generation never +// matches across bumped resumes and the stuck detector goes blind). +event eGNodeFail: (node: int, gen: int, fingerprint: int); +event eGNodeDone: (report: tGReport); +// Read-time session-read registration (R2-M1 read-through): the +// scheduler's reader index must see a read WHILE the reading +// execution is in flight, or the retraction/quiesce race (R2-F1) +// is structurally unreachable and an in-flight reader whose read +// races a re-publish is never retracted. +event eGReadNote: (reader: int, rgen: int, skey: int, val: int, writer: int, wgen: int); +event eGAbortWorker; + +// ---- scheduler self-events ---- +event eGLoopTop; + +// ---- env control ---- +event eGAttemptEnded: (sealed: bool, failed: bool); + +// ---- announce vocabulary (SPEC 7) ---- +event eAnnScenarioInit: (maxStaleness: int); +event eAnnSyncStart: (syncN: int); +event eAnnConsult: (syncN: int, key: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int, node: int, gen: int); +event eAnnClear: (syncN: int, key: int, ghost: tGGhost); +// Replay copy carries the copied rows so P-MARK and the fold can +// ground content without a store readback. +event eAnnReplayCopy: (syncN: int, key: int, vBase: int, rows: seq[tGRow], ghost: tGGhost); +event eAnnUpsert: (syncN: int, key: int, rows: seq[tGRow], ghost: tGGhost); +event eAnnTombstones: (syncN: int, key: int, removes: seq[int], ghost: tGGhost); +event eAnnPublish: (syncN: int, key: int, v: int, ghost: tGGhost); +event eAnnMarkerPut: (syncN: int, key: int, node: int, gen: int, roundId: int, pubBearing: bool, contentEpoch: int, ghost: tGGhost); +event eAnnMarkerDel: (syncN: int, key: int); +// Adoption re-announce: attributes to the ADOPTING execution +// (P-GEN rule R2-N3); adoptedRoundId lets P1 transfer the marked +// round's contribution and P-MARK rebind the marker. +event eAnnAdopt: (syncN: int, key: int, node: int, fromGen: int, toGen: int, adoptedRoundId: int, rows: seq[tGRow], ghost: tGGhost); +event eAnnPoison: (syncN: int, key: int); +event eAnnSessionSet: (syncN: int, skey: int, val: int, writer: int, wgen: int, ghost: tGGhost); +event eAnnSessionRead: (syncN: int, reader: int, rgen: int, skey: int, found: bool, val: int, writer: int, wgen: int); +// Derived announces (G-RULE-1 carrier pin): generation death, forced +// re-admissions, dead reads, pass iterations, budget exhaustion. +// reason: 1 = resume bump, 2 = retraction, 3 = observation pass. +event eAnnGenBump: (syncN: int, node: int, newGen: int, reason: int); +event eAnnReadmit: (syncN: int, node: int, hash: int, gen: int, reason: int); +event eAnnDeadRead: (syncN: int, reader: int, skey: int); +// Resume-time pending purge (E, R2-F5 ∀-predicate) — the G5e +// existence probe's observation point. +event eAnnPurge: (syncN: int, node: int, hash: int); +// A node dispatched while EVERY admitted-by edge names a dead +// generation (dead demand) — unreachable honestly (E purges at +// resume, S refuses at dispatch); the purgeOff kill's alarm. +event eAnnDeadDispatch: (syncN: int, node: int, hash: int); +// Execution-count vocabulary (G6 bake-off): every dispatch announces; +// the env declares the cell's bound once at scenario init. +event eAnnExec: (syncN: int, attempt: int, node: int, gen: int); +event eAnnExecBound: (bound: int); +// Seal-world target (GS-CO-005(d) G5d meta-analysis): the env +// declares the probed world once at scenario init; GSEALWORLD reds +// iff the target sync seals exactly that world. +event eAnnSealWorld: (syncN: int, exp: map[int, int]); +// Attempt-failure vocabulary (G7): the scheduler announces the loud +// failure's generation-blind fingerprint; the env announces abandons. +event eAnnAttemptFail: (syncN: int, attempt: int, node: int, fingerprint: int); +event eAnnAbandon: (syncN: int); +event eAnnPassIter: (syncN: int, iter: int); +event eAnnBudgetExhausted: (syncN: int); +event eAnnCheckpoint: (syncN: int, forced: bool); +event eAnnCrash: (syncN: int); +// Per-announce demand note (G-RULE-1 TIMING PIN): a paginated record +// round's committed page carries its child-naming rows to the +// scheduler AT the page announce, so demand derivation is atomic +// with that announce — the mid-round C-pending & parent-pending +// checkpoint window (G5e) exists only under this timing. Units are +// single atomic commits; their completion carrier IS the announce. +event eGDemandNote: (node: int, gen: int, key: int, rows: seq[tGRow]); + +// Seal announce: partition + manifest + stamps + the final generation +// table (P6-S's dead-set ground). +event eAnnGSeal: (syncN: int, partition: tGPart, manifest: map[int, int], stamps: map[int, map[int, int]], genTable: map[int, int]); +// Scripted seal expectation (SealExpect = closure + content oracle): +// exp maps key -> expected content epoch; excluded keys (poisoned) +// are exempt both directions. +event eAnnExpectSeal: (syncN: int, exp: map[int, int], excluded: map[int, bool]); diff --git a/formal/graph/PSrc/NodeExec.p b/formal/graph/PSrc/NodeExec.p new file mode 100644 index 000000000..14a483cca --- /dev/null +++ b/formal/graph/PSrc/NodeExec.p @@ -0,0 +1,418 @@ +/* MGNodeExec: worker-side execution body (SPEC 3). One execution = + marker check (SPEC 4a) -> consult -> verdict (ADOPT | REPLAY | + CHANGED-WITH-DIFF | FETCH-FRESH) -> emissions. Unit-mode + materialization for replay and diff rounds (settled hand-off); + record rounds for fetch-fresh (no marker, G8a pin). + + SESSION-PUBLISH BODY-OP PIN (R3-F1): a writer's session publish is + a body store op executed by every NON-ADOPTED execution regardless + of verdict class; only adoption skips it. + + Scripted policies (build decisions, CALIBRATION.md): the reader G + always fetches fresh (walker case-7a precedent), so markers arise + on consult-kind and writer-kind nodes only; re-derivations after an + ineligible or refused marker check use fetch-fresh when + cfg.rederiveFresh (the G1(ii)/G1c scripted shape); a writer's + published value is a pure function of its consult epoch (so + same-premise re-derivations re-publish the same value). */ + +machine MGNodeExec { + var sched: machine; + var store: machine; + var upstream: machine; + var agen: int; + var syncN: int; + var attempt: int; + var cfg: tGCfg; + var dead: bool; + var stopAfterConsult: bool; // G3 scripted stop (dispatch flag) + + start state InitW { + entry (p: (sched: machine, store: machine, upstream: machine, agen: int, syncN: int, attempt: int, cfg: tGCfg)) { + sched = p.sched; store = p.store; upstream = p.upstream; + agen = p.agen; syncN = p.syncN; attempt = p.attempt; cfg = p.cfg; + goto IdleW; + } + } + + state IdleW { + on eGDispatch do (p: (pend: tPendingNode, execId: int, attempt: int, stop: bool)) { + stopAfterConsult = p.stop; + runNode(p.pend, p.execId); + } + on eGAbortWorker do { + goto DeadW; + } + } + + state DeadW { + ignore eGDispatch, eGAbortWorker; + } + + fun runNode(pend: tPendingNode, execId: int) { + // Loud deterministic failure (G7): fails at execution start, + // every generation, with a GENERATION-BLIND fingerprint. + if (pend.node == cfg.failNode && syncN == cfg.failSync) { + send sched, eGNodeFail, (node = pend.node, gen = pend.gen, fingerprint = pend.node * 1000 + 7); + return; + } + if (pend.kind == NK_PARENT) { + runParent(pend, execId); + } else if (pend.kind == NK_READER) { + runReader(pend, execId); + } else { + runConsultKind(pend, execId); + } + } + + // ---- parent: fetch-fresh record round, rows name children ---- + fun runParent(pend: tPendingNode, execId: int) { + var rows: seq[tGRow]; + var epoch: int; + var g: tGGhost; + var noPubs: seq[tPub]; + var noReads: seq[tReadRec]; + var stamp: map[int, int]; + g = (roundId = execId, verdict = GV_FRESH, consultEpoch = 0, vBase = -1, lastOp = false, attempt = attempt, node = pend.node, gen = pend.gen); + rows = fetchAll(pend, execId); + if (dead) { abortReport(pend, execId); return; } + epoch = rows[0].epoch; + g.consultEpoch = epoch; + announce eAnnConsult, (syncN = syncN, key = pend.key, hit = false, v = -1, validated = false, epoch = epoch, freshFetch = true, diffVerdict = false, attempt = attempt, node = pend.node, gen = pend.gen); + commitRecordRound(pend, execId, rows, epoch, g); + if (dead) { abortReport(pend, execId); return; } + sendDone(execId, pend, GV_FRESH, rows, noPubs, noReads); + } + + // ---- reader G: always-fresh record round embedding the session + // read; stamp = {G: g} merged with the read value's writer stamp + // (S read-side merge; stampMergeOff is the kill) ---- + fun runReader(pend: tPendingNode, execId: int) { + var rows: seq[tGRow]; + var i: int; + var epoch: int; + var g: tGGhost; + var noPubs: seq[tPub]; + var reads: seq[tReadRec]; + var found: bool; + var sv: int; + var sw: int; + var swg: int; + g = (roundId = execId, verdict = GV_FRESH, consultEpoch = 0, vBase = -1, lastOp = false, attempt = attempt, node = pend.node, gen = pend.gen); + // Session read (observation point (ii): read-through). + found = false; sv = -1; sw = -1; swg = -1; + send store, eGSessionGetReq, (client = this, agen = agen, reader = pend.node, rgen = pend.gen, skey = 0); + receive { + case eGSessionGetResp: (r: (found: bool, val: int, writer: int, wgen: int)) { + found = r.found; sv = r.val; sw = r.writer; swg = r.wgen; + } + case eStoreDead: { dead = true; } + } + if (dead) { abortReport(pend, execId); return; } + if (found) { + reads += (0, (reader = pend.node, rgen = pend.gen, skey = 0, val = sv, writer = sw, wgen = swg)); + // Read-time registration (R2-M1 read-through): the + // scheduler sees the read while this execution flies. + send sched, eGReadNote, (reader = pend.node, rgen = pend.gen, skey = 0, val = sv, writer = sw, wgen = swg); + } + rows = fetchAll(pend, execId); + if (dead) { abortReport(pend, execId); return; } + epoch = rows[0].epoch; + g.consultEpoch = epoch; + i = 0; + while (i < sizeof(rows)) { + if (found) { + rows[i] = (id = rows[i].id, epoch = rows[i].epoch, hops = rows[i].hops, childHash = rows[i].childHash, sVal = sv, sWriter = sw, sWGen = swg); + } + i = i + 1; + } + announce eAnnConsult, (syncN = syncN, key = pend.key, hit = false, v = -1, validated = false, epoch = epoch, freshFetch = true, diffVerdict = false, attempt = attempt, node = pend.node, gen = pend.gen); + commitRecordRoundStamped(pend, execId, rows, epoch, g, readerStamp(pend, sw, swg, found)); + if (dead) { abortReport(pend, execId); return; } + sendDone(execId, pend, GV_FRESH, rows, noPubs, reads); + } + + fun readerStamp(pend: tPendingNode, sw: int, swg: int, found: bool): map[int, int] { + var st: map[int, int]; + st[pend.node] = pend.gen; + if (found && cfg.toggles.stampMerge && sw >= 0) { + st[sw] = swg; + } + return st; + } + + // ---- consult-kind (C) and writer-kind (H) executions ---- + fun runConsultKind(pend: tPendingNode, execId: int) { + var present: bool; + var m: tMarker; + var hit: bool; + var v: int; + var outcome: int; + var epoch: int; + var rederived: bool; + var eligible: bool; + var d2: tDigest; + var g: tGGhost; + var rows: seq[tGRow]; + var ups: seq[tGRow]; + var rms: seq[int]; + var pubs: seq[tPub]; + var noReads: seq[tReadRec]; + var stamp: map[int, int]; + var mk: tMarker; + var isWriter: bool; + var adoptedRows: seq[tGRow]; + var adoptOk: bool; + var verdict: tGVerdict; + isWriter = pend.kind == NK_WRITER; + // Marker check (SPEC 4a). + present = false; + send store, eGMarkerReadReq, (client = this, agen = agen, key = pend.key); + receive { + case eGMarkerReadResp: (r: (present: bool, marker: tMarker)) { + present = r.present; + m = r.marker; + } + case eStoreDead: { dead = true; } + } + if (dead) { abortReport(pend, execId); return; } + // One consult per execution (the marker path's re-consult is + // THE consult when it falls through to re-derivation). + hit = false; v = -1; + send store, eGLookupReq, (client = this, agen = agen, key = pend.key); + receive { + case eGLookupResp: (r: (hit: bool, v: int)) { hit = r.hit; v = r.v; } + case eStoreDead: { dead = true; } + } + if (dead) { abortReport(pend, execId); return; } + send upstream, eValidateReq, (client = this, scope = pend.key, v = v); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { + epoch = r.epoch; + if (!hit) { outcome = 0; } + else if (r.ok) { outcome = 1; } + else { outcome = 2; } + } + } + rederived = false; + if (present && !m.voided) { + // ADOPTION ELIGIBILITY (round-2 pins): MATCH-only (R2-F3; + // adoptOnFail waives) and writer-ineligibility (R2-F2; + // writerAdopt waives). Digest EQUAL and eligible -> ADOPT. + d2 = (v = v, outcome = outcome, sVal = -1, sWriter = -1, sWGen = -1, hasSess = false); + eligible = (outcome == 1 || cfg.toggles.adoptOnFail) && d2 == m.digest && (!m.pubBearing || cfg.toggles.writerAdopt); + if (eligible) { + // The consult that justifies the adoption is announced + // BEFORE the adopt commits (P-ADOPT ordering: the + // justification precedes the act). + announce eAnnConsult, (syncN = syncN, key = pend.key, hit = hit, v = v, validated = outcome == 1, epoch = epoch, freshFetch = false, diffVerdict = false, attempt = attempt, node = pend.node, gen = pend.gen); + g = (roundId = execId, verdict = GV_ADOPT, consultEpoch = epoch, vBase = m.contentEpoch, lastOp = true, attempt = attempt, node = pend.node, gen = pend.gen); + adoptOk = false; + send store, eGAdoptReq, (client = this, agen = agen, key = pend.key, node = pend.node, fromGen = m.gen, toGen = pend.gen, roundId = m.roundId, allowLiveFrom = !cfg.toggles.suppression, ghost = g); + receive { + case eGAdoptResp: (r: (ok: bool, rows: seq[tGRow])) { + adoptOk = r.ok; + adoptedRows = r.rows; + } + case eStoreDead: { dead = true; } + } + if (dead) { abortReport(pend, execId); return; } + if (adoptOk) { + sendDone(execId, pend, GV_ADOPT, adoptedRows, pubs, noReads); + return; + } + } + rederived = true; + } + // Verdict as if unmarked (SPEC 4a re-derive clause). + if (outcome == 1) { + verdict = GV_REPLAY; + } else if (outcome == 2 && cfg.diffPolicy && !(cfg.rederiveFresh && rederived)) { + verdict = GV_DIFF; + } else { + verdict = GV_FRESH; + } + announce eAnnConsult, (syncN = syncN, key = pend.key, hit = hit, v = v, validated = outcome == 1, epoch = epoch, freshFetch = verdict == GV_FRESH, diffVerdict = verdict == GV_DIFF, attempt = attempt, node = pend.node, gen = pend.gen); + // Scripted graceful stop (G3, walker case 3): AFTER the + // consult, before any round commit — the node stays pending + // at its consult-granularity cursor. + if (stopAfterConsult) { + stopAfterConsult = false; + send sched, eGStopReq, (node = pend.node, gen = pend.gen); + return; + } + // Writer body op (R3-F1 pin): session publish on every + // non-adopted execution, before the round's store commit. + if (isWriter) { + g = (roundId = execId, verdict = verdict, consultEpoch = epoch, vBase = -1, lastOp = false, attempt = attempt, node = pend.node, gen = pend.gen); + send store, eGSessionPub, (client = this, agen = agen, skey = 0, val = epoch, writer = pend.node, wgen = pend.gen, ghost = g); + receive { + case eStoreAck: {} + case eStoreDead: { dead = true; } + } + if (dead) { abortReport(pend, execId); return; } + pubs += (0, (skey = 0, val = epoch, wgen = pend.gen)); + } + stamp = default(map[int, int]); + stamp[pend.node] = pend.gen; + if (verdict == GV_REPLAY) { + mk = (node = pend.node, gen = pend.gen, roundId = execId, digest = (v = v, outcome = 1, sVal = -1, sWriter = -1, sWGen = -1, hasSess = false), pubBearing = isWriter, voided = false, contentEpoch = v); + g = (roundId = execId, verdict = GV_REPLAY, consultEpoch = epoch, vBase = v, lastOp = true, attempt = attempt, node = pend.node, gen = pend.gen); + send store, eGReplayUnit, (client = this, agen = agen, key = pend.key, v = epoch, marker = mk, stamp = stamp, hash = pend.hash, ghost = g); + receive { + case eGUnitResp: (r: (rows: seq[tGRow])) { rows = r.rows; } + case eStoreDead: { dead = true; } + } + if (dead) { abortReport(pend, execId); return; } + sendDone(execId, pend, GV_REPLAY, rows, pubs, noReads); + return; + } + if (verdict == GV_DIFF) { + send upstream, eDiffReq, (client = this, scope = pend.key, fromEpoch = v, page = 0); + receive { + case eDiffResp: (r: (upserts: seq[tGRow], removes: seq[int], epoch: int, morePages: bool)) { ups = r.upserts; } + } + send upstream, eDiffReq, (client = this, scope = pend.key, fromEpoch = v, page = 1); + receive { + case eDiffResp: (r: (upserts: seq[tGRow], removes: seq[int], epoch: int, morePages: bool)) { rms = r.removes; } + } + mk = (node = pend.node, gen = pend.gen, roundId = execId, digest = (v = v, outcome = 2, sVal = -1, sWriter = -1, sWGen = -1, hasSess = false), pubBearing = isWriter, voided = false, contentEpoch = epoch); + g = (roundId = execId, verdict = GV_DIFF, consultEpoch = epoch, vBase = v, lastOp = true, attempt = attempt, node = pend.node, gen = pend.gen); + send store, eGOverlayUnit, (client = this, agen = agen, key = pend.key, v = epoch, upserts = ups, removes = rms, marker = mk, stamp = stamp, hash = pend.hash, composeDead = cfg.toggles.overlayComposeDead, ghost = g); + receive { + case eGUnitResp: (r: (rows: seq[tGRow])) { rows = r.rows; } + case eStoreDead: { dead = true; } + } + if (dead) { abortReport(pend, execId); return; } + sendDone(execId, pend, GV_DIFF, rows, pubs, noReads); + return; + } + // FETCH-FRESH record round (no marker, G8a pin). + g = (roundId = execId, verdict = GV_FRESH, consultEpoch = epoch, vBase = -1, lastOp = false, attempt = attempt, node = pend.node, gen = pend.gen); + rows = fetchAll(pend, execId); + if (dead) { abortReport(pend, execId); return; } + commitRecordRound(pend, execId, rows, epoch, g); + if (dead) { abortReport(pend, execId); return; } + sendDone(execId, pend, GV_FRESH, rows, pubs, noReads); + } + + // Fetch every page of the node's key at the current epoch, + // decorated with the cell's child-naming script. + fun fetchAll(pend: tPendingNode, execId: int): seq[tGRow] { + var rows: seq[tGRow]; + var page: int; + var more: bool; + var i: int; + var r: tGRow; + var ch: int; + page = 0; + more = true; + while (more) { + send upstream, eFetchReq, (client = this, scope = pend.key, page = page); + receive { + case eFetchResp: (rp: (rows: seq[tGRow], epoch: int, morePages: bool)) { + i = 0; + while (i < sizeof(rp.rows)) { + r = rp.rows[i]; + ch = childHashFor(cfg.cell, pend.node, r.id); + if (ch > 0) { + r = (id = r.id, epoch = r.epoch, hops = r.hops, childHash = ch, sVal = r.sVal, sWriter = r.sWriter, sWGen = r.sWGen); + } + rows += (sizeof(rows), r); + i = i + 1; + } + more = rp.morePages; + } + } + page = page + 1; + } + return rows; + } + + fun commitRecordRound(pend: tPendingNode, execId: int, rows: seq[tGRow], epoch: int, g: tGGhost) { + var stamp: map[int, int]; + stamp[pend.node] = pend.gen; + commitRecordRoundStamped(pend, execId, rows, epoch, g, stamp); + } + + // Record round (REPLACES): clear (deleting the marker — the + // markerCleanup toggle removes exactly that, R2-F4), per-page + // upserts, publish. Per-op commits give the crash protocol its + // windows. + fun commitRecordRoundStamped(pend: tPendingNode, execId: int, rows: seq[tGRow], epoch: int, g: tGGhost, stamp: map[int, int]) { + var i: int; + var pageRows: seq[tGRow]; + send store, eGClearScope, (client = this, agen = agen, key = pend.key, delMarker = cfg.toggles.markerCleanup, ghost = g); + receive { + case eStoreAck: {} + case eStoreDead: { dead = true; } + } + if (dead) { return; } + i = 0; + while (i < sizeof(rows)) { + pageRows = default(seq[tGRow]); + pageRows += (0, rows[i]); + send store, eGUpsertPage, (client = this, agen = agen, key = pend.key, rows = pageRows, ghost = g); + receive { + case eStoreAck: {} + case eStoreDead: { dead = true; } + } + if (dead) { return; } + // Per-announce demand derivation (G-RULE-1 TIMING PIN): + // a committed child-naming page reaches the scheduler AT + // the page announce, not at completion — the mid-round + // checkpoint window (G5e) exists only under this timing. + if (pageRows[0].childHash > 0) { + send sched, eGDemandNote, (node = pend.node, gen = pend.gen, key = pend.key, rows = pageRows); + } + i = i + 1; + } + g.lastOp = true; + send store, eGPublishEntry, (client = this, agen = agen, key = pend.key, v = epoch, stamp = stamp, hash = pend.hash, ghost = g); + receive { + case eStoreAck: {} + case eStoreDead: { dead = true; } + } + } + + fun sendDone(execId: int, pend: tPendingNode, verdict: tGVerdict, rows: seq[tGRow], pubs: seq[tPub], reads: seq[tReadRec]) { + send sched, eGNodeDone, (report = (execId = execId, node = pend.node, gen = pend.gen, hash = pend.hash, key = pend.key, kind = pend.kind, verdict = verdict, rows = rows, pubs = pubs, reads = reads, aborted = false),); + } + + fun abortReport(pend: tPendingNode, execId: int) { + var noRows: seq[tGRow]; + var noPubs: seq[tPub]; + var noReads: seq[tReadRec]; + send sched, eGNodeDone, (report = (execId = execId, node = pend.node, gen = pend.gen, hash = pend.hash, key = pend.key, kind = pend.kind, verdict = GV_FRESH, rows = noRows, pubs = noPubs, reads = noReads, aborted = true),); + goto DeadW; + } +} + +// Child-naming script (G-RULE-1: demand rides row content). +fun childHashFor(cell: int, node: int, rowId: int): int { + if (cell == 11 && node == 0) { return 2; } // P names C on every row + if (cell == 21 && node == 0 && rowId == 0) { return 3; } // P names H + if (cell == 21 && node == 0 && rowId == 1) { return 4; } // P names G + // Cell 24 (G5 family): the PAGINATED parent names C on page 1 + // ONLY — the row the e1->e2 mutation deletes, so the re-execution + // at e2 emits no child naming (upstream demand shrink). + if (cell == 24 && node == 0 && rowId == 1) { return 2; } + if (cell == 25 && node == 0) { return 2; } // G3: cell-11 topology + // Cell 26 (G6a/b chain): P -> S1 -> C -> GC; S1 names C on its + // page-1 row (the row the e1->e2 mutation deletes: G6b's shrink). + if (cell == 26 && node == 0) { return 2; } + if (cell == 26 && node == 1 && rowId == 1) { return 5; } + if (cell == 26 && node == 4 && rowId == 0) { return 6; } + // Cell 27 (G7): cell-11 topology. + if (cell == 27 && node == 0) { return 2; } + // Cell 28 (G6c fan-in): P names S1 + S2; both name C. + if (cell == 28 && node == 0 && rowId == 0) { return 2; } + if (cell == 28 && node == 0 && rowId == 1) { return 5; } + if (cell == 28 && node == 1 && rowId == 0) { return 6; } + if (cell == 28 && node == 4 && rowId == 0) { return 6; } + // Cell 29 (G8c same-key): P names two DISTINCT derivations that + // share output key 1 (keyOf). + if (cell == 29 && node == 0 && rowId == 0) { return 2; } + if (cell == 29 && node == 0 && rowId == 1) { return 5; } + return 0; +} diff --git a/formal/graph/PSrc/Sched.p b/formal/graph/PSrc/Sched.p new file mode 100644 index 000000000..51037e843 --- /dev/null +++ b/formal/graph/PSrc/Sched.p @@ -0,0 +1,818 @@ +/* MGraphSched: the frontier scheduler, one machine per attempt + (SPEC 3). Owns the frontier, admitted-derivation set (G-RULE-2 + death semantics), generation-qualified admitted-by edges, the + generation table (G-RULE-3), demand derivation (G-RULE-1), lineage + state per variant, and dispatch to 2 workers. + + Announce processing is per-carrier atomic: a worker's completion + report (eGNodeDone) hosts all derived effects — demand admissions, + retraction enqueues (E+B), dead-read observations (S), deferred + quiesce bumps — emitted as derived announces inside that handler + (G-RULE-1 derived-announce carrier pin, R2-M2). + + Elective checkpoints commit at loop tops under a genuine choice + point (SPEC 3: placement a choice point — the G1e/R3-F2 crash + window needs skip schedules). The forced resume checkpoint (F4) + and the mid-bump fence (R3-F2) are UNCONDITIONAL commits, removed + only by their kill toggles. */ + +machine MGraphSched { + var env: machine; + var store: machine; + var upstream: machine; + var agen: int; + var syncN: int; + var attempt: int; + var cfg: tGCfg; + var frontier: seq[tPendingNode]; + var admitted: map[int, bool]; + var completedH: map[int, bool]; + var edges: map[int, seq[tEdge]]; + var genTable: map[int, int]; + var readers: seq[tReadRec]; + var retractQ: seq[int]; // reader nodes owing a re-run (E+B) + var deferredBumps: seq[int]; // quiesce-deferred bump targets + var workers: seq[machine]; + var busyW: map[machine, bool]; + var owner: map[int, machine]; // execId -> worker + var outstanding: map[int, tPendingNode]; + var inFlight: map[int, int]; // node -> execId + var execSeq: int; + var storeDead: bool; + var passIters: int; + var droppedHash: int; // demandDrop inject target (0 = unarmed) + var carrierDirty: bool; + var catchupDone: map[int, bool]; // reader*100+wgen -> catch-up retraction spent + + start state Boot { + entry (p: (env: machine, store: machine, upstream: machine, agen: int, syncN: int, attempt: int, cfg: tGCfg, ck: tGCkpt, has: bool)) { + var i: int; + var j: int; + var pend: tPendingNode; + var bumped: seq[int]; + var hs: seq[int]; + var stillPending: map[int, bool]; + env = p.env; store = p.store; upstream = p.upstream; + agen = p.agen; syncN = p.syncN; attempt = p.attempt; cfg = p.cfg; + execSeq = agen * 100; + if (!p.has) { + // Fresh roots (attempt 1, or crash before any durable + // checkpoint: restart-from-root). + rootFrontier(); + // F4 mint fence (R3-F2 extension): the initial minted + // table is durable BEFORE first dispatch, so a later + // attempt always restores past these identities. + if (cfg.toggles.resumeCkpt) { + doCheckpoint(true); + if (storeDead) { goto DeadSched; } + } + } else { + frontier = p.ck.pending; + admitted = p.ck.admitted; + edges = p.ck.edges; + genTable = p.ck.genTable; + readers = p.ck.readers; + // Resume (SPEC 3): bump every pending node (the prior + // generation is dead)... + i = 0; + while (i < sizeof(frontier)) { + pend = frontier[i]; + if (!inIntSeq(bumped, pend.node)) { + genTable[pend.node] = genTable[pend.node] + 1; + // Resume bumps are re-mints: bucket-aligned + // under compression (G9-CAL-1). + if (cfg.stampCompression && genTable[pend.node] % 2 == 1) { + genTable[pend.node] = genTable[pend.node] + 1; + } + bumped += (sizeof(bumped), pend.node); + } + pend.gen = genTable[pend.node]; + frontier[i] = pend; + i = i + 1; + } + // ...variant E purges pending nodes under the + // ∀-PREDICATE (R2-F5: purge only when EVERY admitted-by + // edge names a dead generation), removing purged hashes + // from the admitted-derivation set. Roots (no edges) + // never purge. + if (cfg.lineage == LIN_E && cfg.toggles.purge) { + i = 0; + while (i < sizeof(frontier)) { + pend = frontier[i]; + if (pend.hash in edges && sizeof(edges[pend.hash]) > 0 && allEdgesDead(pend.hash)) { + announce eAnnPurge, (syncN = syncN, node = pend.node, hash = pend.hash); + admitted -= pend.hash; + frontier -= i; + } else { + i = i + 1; + } + } + } + // Completed iff admitted ∧ ¬pending, evaluated AFTER + // removals (G-RULE-2 resume rule). + i = 0; + while (i < sizeof(frontier)) { + stillPending[frontier[i].hash] = true; + i = i + 1; + } + hs = keys(admitted); + i = 0; + while (i < sizeof(hs)) { + if (!(hs[i] in stillPending)) { + completedH[hs[i]] = true; + } + i = i + 1; + } + // FORCED RESUME CHECKPOINT (F4): the bumped table is + // durable before any dispatch; resume bumps ride its + // commit (R2-M2). resumeCkptOff is the G1b kill. + if (cfg.toggles.resumeCkpt) { + doCheckpoint(true); + if (storeDead) { goto DeadSched; } + } + i = 0; + while (i < sizeof(bumped)) { + announce eAnnGenBump, (syncN = syncN, node = bumped[i], newGen = genTable[bumped[i]], reason = 1); + i = i + 1; + } + } + i = 0; + while (i < cfg.nWorkers) { + workers += (sizeof(workers), new MGNodeExec((sched = this, store = store, upstream = upstream, agen = agen, syncN = syncN, attempt = attempt, cfg = cfg))); + i = i + 1; + } + goto Running; + } + } + + state Running { + entry { + loopTop(); + } + + on eGLoopTop do { + loopTop(); + } + + on eGReadNote do (p: (reader: int, rgen: int, skey: int, val: int, writer: int, wgen: int)) { + var isDead: bool; + readers += (sizeof(readers), (reader = p.reader, rgen = p.rgen, skey = p.skey, val = p.val, writer = p.writer, wgen = p.wgen)); + isDead = p.wgen >= 0 && p.writer in genTable && p.wgen < genTable[p.writer]; + if (isDead) { + // S observation point (ii): dead-read count. + announce eAnnDeadRead, (syncN = syncN, reader = p.reader, skey = p.skey); + } + // E+B registration-side CATCH-UP retraction, ONCE per + // (reader, dead wgen): a read that registers after its + // value's death was already knowable may have missed the + // re-publish carrier's retraction (note-vs-carrier race); + // repeated retraction is exclusively RE-PUBLISH-driven + // (R2-M6(i)), so an unretractable strand (writerAdopt: + // the writer adopts and never re-publishes) costs one + // bounded re-run and then SEALS, where P6-E reds the + // still-dead final read. An unbounded registration-side + // rule livelocks that cell instead: the frontier never + // drains and the at-seal oracle never evaluates. + if (isDead && cfg.lineage == LIN_E && cfg.sessVar == SESS_B && cfg.toggles.retraction) { + if (p.reader in genTable && p.rgen == genTable[p.reader] && !((p.reader * 100 + p.wgen) in catchupDone)) { + catchupDone[p.reader * 100 + p.wgen] = true; + if (cfg.toggles.quiesce && p.reader in inFlight) { + if (!inIntSeq(deferredBumps, p.reader)) { + deferredBumps += (sizeof(deferredBumps), p.reader); + } + } else { + bumpAndReadmit(p.reader, 2); + if (storeDead) { goto DeadSched; } + if (sizeof(frontier) > 0) { dispatchFree(); } + } + } + } + } + + on eGDemandNote do (p: (node: int, gen: int, key: int, rows: seq[tGRow])) { + var i: int; + // A dead generation's late page note derives nothing: + // demand rides LIVE emissions (the live re-run re-derives + // its own naming). + if (!(p.node in genTable) || p.gen != genTable[p.node]) { return; } + carrierDirty = false; + i = 0; + while (i < sizeof(p.rows)) { + if (p.rows[i].childHash > 0) { + admitChild(p.rows[i].childHash, p.node, p.gen); + } + i = i + 1; + } + // The note is its own carrier: its derived effects commit + // as ONE durable delta (GS-CO-003 discipline; GS-CO-001(b): + // no minted generation dispatches before its table delta). + if (carrierDirty && cfg.toggles.midBumpFence) { + doCheckpoint(true); + } + if (storeDead) { goto DeadSched; } + if (sizeof(frontier) > 0) { dispatchFree(); } + } + + on eGNodeFail do (p: (node: int, gen: int, fingerprint: int)) { + var i: int; + // Loud attempt failure (G7): announce the generation-blind + // fingerprint, park the workers, end failed. No forced + // checkpoint — the resume restores the last durable one. + announce eAnnAttemptFail, (syncN = syncN, attempt = attempt, node = p.node, fingerprint = p.fingerprint); + i = 0; + while (i < sizeof(workers)) { + send workers[i], eGAbortWorker; + i = i + 1; + } + send env, eGAttemptEnded, (sealed = false, failed = true); + goto DoneSched; + } + + on eGStopReq do (p: (node: int, gen: int)) { + var i: int; + // Graceful stop (G3): checkpoint with the stopped node + // still pending at its cursor (buildCheckpoint includes + // in-flight nodes), park the workers, end unsealed. The + // store lives; resume bumps the stopped generation. + doCheckpoint(false); + if (storeDead) { goto DeadSched; } + i = 0; + while (i < sizeof(workers)) { + send workers[i], eGAbortWorker; + i = i + 1; + } + send env, eGAttemptEnded, (sealed = false, failed = false); + goto DoneSched; + } + + on eGNodeDone do (p: (report: tGReport)) { + var r: tGReport; + var i: int; + var w: machine; + r = p.report; + w = owner[r.execId]; + owner -= r.execId; + busyW -= w; + outstanding -= r.execId; + if (r.node in inFlight && inFlight[r.node] == r.execId) { + inFlight -= r.node; + } + if (r.aborted) { + storeDead = true; + goto DeadSched; + } + completedH[r.hash] = true; + // Retraction-queue drain (E): the re-admitted reader's + // completion removes its entry. + i = 0; + while (i < sizeof(retractQ)) { + if (retractQ[i] == r.node) { + retractQ -= i; + } else { + i = i + 1; + } + } + // Demand derivation from announced row content (G-RULE-1), + // atomic with this carrier. + carrierDirty = false; + i = 0; + while (i < sizeof(r.rows)) { + if (r.rows[i].childHash > 0) { + admitChild(r.rows[i].childHash, r.node, r.gen); + } + i = i + 1; + } + // CARRIER-DURABILITY FENCE (GS-CO-003): the carrier's + // derived effects — every admission, mint, and + // admitted-by edge — commit durably as ONE delta, and no + // checkpoint may separate the carrier's completion from + // its admissions. Per-mint fencing leaves a lost-demand + // window: crash between two children's fences restores + // the parent COMPLETED with the second child's admission + // gone, and a completed parent never re-derives — the + // demand starves and the closure oracle reds an honest + // history. + if (carrierDirty && cfg.toggles.midBumpFence) { + doCheckpoint(true); + } + if (storeDead) { goto DeadSched; } + // Session reads register at READ time (eGReadNote, + // R2-M1 read-through) — NOT here: carrier-time + // registration makes the in-flight retraction race + // (R2-F1) unreachable. + // Re-publish reader retraction (E+B): enqueue a retraction + // entry per reader execution of the now-dead value + // (SPEC 3 retraction queue; keying per MSessionStore). + if (cfg.lineage == LIN_E && cfg.sessVar == SESS_B && cfg.toggles.retraction) { + i = 0; + while (i < sizeof(r.pubs)) { + retractReaders(r.pubs[i].skey, r.node, r.pubs[i].wgen); + i = i + 1; + } + } + // Quiesce-deferred bump lands atomically with the dying + // execution's completion (R2-F1). + i = 0; + while (i < sizeof(deferredBumps)) { + if (deferredBumps[i] == r.node) { + deferredBumps -= i; + bumpAndReadmit(r.node, 2); + } else { + i = i + 1; + } + } + if (storeDead) { goto DeadSched; } + if (sizeof(outstanding) == 0) { + send this, eGLoopTop; + } else if (sizeof(frontier) > 0) { + dispatchFree(); + } + } + } + + state DoneSched { + ignore eGLoopTop, eGNodeDone, eGReadNote, eGDemandNote, eGStopReq, eGNodeFail; + } + + // Crashed attempt: ops from this agen are dropped; workers park; + // MEnv resumes independently from the last durable checkpoint. + state DeadSched { + entry { + var i: int; + i = 0; + while (i < sizeof(workers)) { + send workers[i], eGAbortWorker; + i = i + 1; + } + } + ignore eGLoopTop, eGNodeDone, eGReadNote, eGDemandNote, eGStopReq, eGNodeFail; + } + + fun loopTop() { + if (storeDead) { goto DeadSched; } + // Elective checkpoint: placement is a genuine choice point. + if (choose(2) == 0) { + doCheckpoint(false); + if (storeDead) { goto DeadSched; } + } + if (sizeof(frontier) == 0 && sizeof(outstanding) == 0) { + sealPhase(); + return; + } + dispatchFree(); + } + + fun dispatchFree() { + var pend: tPendingNode; + var w: machine; + var found: bool; + var i: int; + while (sizeof(frontier) > 0 && freeWorkerExists()) { + pend = frontier[0]; + frontier -= 0; + // S observation point (i): dispatch-time refusal — a + // pending node all of whose admission edges name dead + // generations is dropped (hash removed, G-RULE-2) unless + // a live re-derivation re-admitted it. + if (cfg.lineage == LIN_S && pend.hash in edges && sizeof(edges[pend.hash]) > 0 && allEdgesDead(pend.hash)) { + admitted -= pend.hash; + continue; + } + // Dead-demand dispatch (unreachable honestly: E purges at + // resume, S refuses above) — the purgeOff kill's alarm. + if (pend.hash in edges && sizeof(edges[pend.hash]) > 0 && allEdgesDead(pend.hash)) { + announce eAnnDeadDispatch, (syncN = syncN, node = pend.node, hash = pend.hash); + } + found = false; + i = 0; + while (i < sizeof(workers) && !found) { + if (!(workers[i] in busyW)) { + w = workers[i]; + found = true; + } + i = i + 1; + } + execSeq = execSeq + 1; + outstanding[execSeq] = pend; + owner[execSeq] = w; + busyW[w] = true; + inFlight[pend.node] = execSeq; + announce eAnnExec, (syncN = syncN, attempt = attempt, node = pend.node, gen = pend.gen); + send w, eGDispatch, (pend = pend, execId = execSeq, attempt = attempt, stop = cfg.interrupt == 1 && syncN == cfg.interruptSync && attempt == 1 && pend.node == 1); + } + } + + fun freeWorkerExists(): bool { + var i: int; + i = 0; + while (i < sizeof(workers)) { + if (!(workers[i] in busyW)) { return true; } + i = i + 1; + } + return false; + } + + // Demand admission (G-RULE-2): MUST suppress iff the hash is + // pending or completed this sync; purge/refusal removals make a + // live re-derivation re-admissible. suppressionOff duplicates run + // at the SAME generation (identity-duplicate mutant; the racing + // schedule is the P1-LEGALITY first-find, sequential schedules + // adopt with the declared live-fromGen deviation, R2-N1). + fun admitChild(h: int, parent: int, pgen: int) { + var node: int; + var g: int; + var es: seq[tEdge]; + var dup: bool; + var dupGen: int; + var i: int; + dup = false; + i = 0; + while (i < sizeof(frontier)) { + if (frontier[i].hash == h) { dup = true; dupGen = frontier[i].gen; } + i = i + 1; + } + i = 0; + while (i < sizeof(keys(outstanding))) { + if (outstanding[keys(outstanding)[i]].hash == h) { dup = true; dupGen = outstanding[keys(outstanding)[i]].gen; } + i = i + 1; + } + if (cfg.toggles.suppression && (dup || h in completedH)) { + // Edge-only registration still dirties the carrier: a + // LOST live admitted-by edge mis-arms the ∀-purge + // predicate on resume (GS-CO-003 covers edges too). + // Idempotent per (parent, pgen): the page note and the + // completion carrier derive the same emission once. + if (!hasEdge(h, parent, pgen)) { + if (h in edges) { es = edges[h]; } + es += (sizeof(es), (parent = parent, pgen = pgen)); + edges[h] = es; + carrierDirty = true; + } + return; + } + if (cfg.toggles.demandDrop && (droppedHash == 0 || droppedHash == h)) { + // INJECT (G5f kill): silently drop every admission of the + // first hash a derivation names — a lost derivation + // PATHWAY, not a lost message (per-announce notes and the + // completion carrier derive the same emission twice, so a + // single-message drop is always healed; calibration find). + droppedHash = h; + return; + } + node = h - 1; + if (dup) { + g = dupGen; + } else { + if (node in genTable) { + genTable[node] = genTable[node] + 1; + // Refusal re-admissions are re-mints: bucket-aligned + // under compression (G9-CAL-1, see bumpAndReadmit). + if (cfg.stampCompression && genTable[node] % 2 == 1) { + genTable[node] = genTable[node] + 1; + } + } else { + genTable[node] = 1; + } + g = genTable[node]; + } + admitted[h] = true; + if (h in completedH) { completedH -= h; } + if (!hasEdge(h, parent, pgen)) { + if (h in edges) { es = edges[h]; } + es += (sizeof(es), (parent = parent, pgen = pgen)); + edges[h] = es; + } + frontier += (sizeof(frontier), (node = node, kind = kindOf(cfg.cell, node), hash = h, key = keyOf(cfg.cell, node), gen = g)); + carrierDirty = true; + // Durability rides the CARRIER fence (GS-CO-003), committed + // once after the whole demand loop — never per-mint. + } + + fun hasEdge(h: int, parent: int, pgen: int): bool { + var i: int; + var es: seq[tEdge]; + if (!(h in edges)) { return false; } + es = edges[h]; + i = 0; + while (i < sizeof(es)) { + if (es[i].parent == parent && es[i].pgen == pgen) { return true; } + i = i + 1; + } + return false; + } + + // E+B retraction (SPEC 3): a re-publish under wgen retracts every + // reader execution of the same key's earlier (now-dead) value — + // including re-runs that read a stale value before the re-publish + // landed (the G-pending re-retraction clause, R2-M6(i)). + fun retractReaders(skey: int, writer: int, wgen: int) { + var i: int; + var rd: int; + var seen: seq[int]; + i = 0; + while (i < sizeof(readers)) { + if (readers[i].skey == skey && readers[i].writer == writer && readers[i].wgen < wgen) { + rd = readers[i].reader; + if (!inIntSeq(seen, rd) && rd in genTable && readers[i].rgen == genTable[rd]) { + seen += (sizeof(seen), rd); + if (!inIntSeq(retractQ, rd)) { + retractQ += (sizeof(retractQ), rd); + } + // QUIESCE-BEFORE-BUMP (R2-F1): defer while the + // dying generation's execution is in flight; + // quiesceOff is the G1d kill. + if (cfg.toggles.quiesce && rd in inFlight) { + if (!inIntSeq(deferredBumps, rd)) { + deferredBumps += (sizeof(deferredBumps), rd); + } + } else { + bumpAndReadmit(rd, 2); + } + } + } + i = i + 1; + } + } + + // Mid-attempt bump + re-admission (retraction- or observation- + // forced). MID-BUMP FENCE (R3-F2): the bump's generation-table + // delta commits durably (forced checkpoint) between the bump's + // carrier announce and the new generation's first dispatch; + // midBumpFenceOff is the G1e kill. + fun bumpAndReadmit(node: int, reason: int) { + var h: int; + var i: int; + var updated: bool; + var pend: tPendingNode; + genTable[node] = genTable[node] + 1; + // Under compression every scheduler RE-mint is BUCKET-ALIGNED + // (even): floor-bucketed stamps prove liveness only on bucket + // boundaries, and an unaligned heal re-creates the odd + // generation it just chased one demand-level down — the pass + // then needs O(demand-depth) iterations and reds PASS-BUDGET + // on honest histories (G9-CAL-1). First-admission mints stay + // at 1, so the mixed-parity stamp population compression must + // digest — and its redo cost — remain in the model. + if (cfg.stampCompression && genTable[node] % 2 == 1) { + genTable[node] = genTable[node] + 1; + } + announce eAnnGenBump, (syncN = syncN, node = node, newGen = genTable[node], reason = reason); + h = node + 1; + admitted[h] = true; + if (h in completedH) { completedH -= h; } + // If the node is already pending, re-ground that entry at the + // new generation instead of duplicating it (a duplicate would + // dispatch the dead generation a second time). + updated = false; + i = 0; + while (i < sizeof(frontier)) { + if (frontier[i].node == node) { + pend = frontier[i]; + pend.gen = genTable[node]; + frontier[i] = pend; + updated = true; + } + i = i + 1; + } + if (!updated) { + frontier += (sizeof(frontier), (node = node, kind = kindOf(cfg.cell, node), hash = h, key = keyOf(cfg.cell, node), gen = genTable[node])); + } + if (cfg.toggles.midBumpFence) { + doCheckpoint(true); + if (storeDead) { return; } + } + announce eAnnReadmit, (syncN = syncN, node = node, hash = h, gen = genTable[node], reason = reason); + } + + fun allEdgesDead(h: int): bool { + var i: int; + var es: seq[tEdge]; + es = edges[h]; + i = 0; + while (i < sizeof(es)) { + if (!(es[i].parent in genTable) || es[i].pgen >= genTable[es[i].parent]) { + return false; + } + i = i + 1; + } + return true; + } + + // SEAL SEQUENCE (SPEC 3): frontier drained -> pre-seal pass (S) / + // retraction queue empty (E) -> SWEEP -> eSeal. + fun sealPhase() { + var stamps: map[int, map[int, int]]; + var owners: map[int, int]; + var ks: seq[int]; + var ns: seq[int]; + var i: int; + var j: int; + var forced: bool; + var got: bool; + var keep: seq[int]; + // The pass's domain is the DEMAND CLOSURE: a dead stamp on an + // out-of-closure key owes nothing — the sweep drops the key. + // Chasing it burns the pass budget on an honest history (the + // G5 shrink chassis: the refused node's key keeps its stale + // stamp forever). Recomputed on every sealPhase entry, so a + // forced re-run's naming changes are honored next scan. + keep = computeClosure(); + if (storeDead) { goto DeadSched; } + if (cfg.lineage == LIN_S) { + // PRE-SEAL PASS (observation point (iii)): one iteration = + // one scan over a drained frontier (R3-M3); budget <= 3 + // (R2-M7); a budget-exhausted seal is announce-visible and + // P6-S catches surviving dead stamps at seal. + if (passIters < 3) { + got = false; + send store, eGReadStampsReq, (client = this, agen = agen); + receive { + case eGReadStampsResp: (r: (stamps: map[int, map[int, int]], owners: map[int, int])) { + stamps = r.stamps; + owners = r.owners; + got = true; + } + case eStoreDead: { storeDead = true; } + } + if (!got) { goto DeadSched; } + passIters = passIters + 1; + announce eAnnPassIter, (syncN = syncN, iter = passIters); + forced = false; + ks = keys(stamps); + i = 0; + while (i < sizeof(ks)) { + if (!inIntSeq(keep, ks[i])) { i = i + 1; continue; } + ns = keys(stamps[ks[i]]); + j = 0; + while (j < sizeof(ns)) { + if (ns[j] in genTable && staleStamp(stamps[ks[i]][ns[j]], genTable[ns[j]]) ) { + if (!forcedAlready(ks[i], owners)) { + bumpAndReadmit(owners[ks[i]], 3); + if (storeDead) { goto DeadSched; } + forced = true; + } + // Compressed AMBIGUOUS entry (G9-CAL-1): + // floor(s) == cur - 1 with cur ODD means s + // may EQUAL cur — a live entry the owner's + // re-run cannot make provable (the re-read + // merges the named node's unchanged odd + // generation forever). The heal also bumps + // the NAMED node onto an even generation: + // parity ambiguity dies with the odd gen, + // and any raced re-read that merged the + // old gen becomes unambiguously DEAD for + // the next scan's owner-bump rule. + if (cfg.stampCompression && ns[j] != owners[ks[i]] + && genTable[ns[j]] % 2 == 1 + && stamps[ks[i]][ns[j]] - stamps[ks[i]][ns[j]] % 2 == genTable[ns[j]] - 1) { + if (!nodeInFrontier(ns[j])) { + bumpAndReadmit(ns[j], 3); + if (storeDead) { goto DeadSched; } + forced = true; + } + } + } + j = j + 1; + } + i = i + 1; + } + if (forced) { + // Un-drained frontier: resume dispatch; the next + // scan begins only after it re-drains. + dispatchFree(); + return; + } + } else { + announce eAnnBudgetExhausted, (syncN = syncN,); + } + } + if (cfg.toggles.sweepOverreach && sizeof(keep) > 1) { + // INJECT (G5c kill): drop an in-closure key from the keep + // set (the last discovered, never the root). + keep -= (sizeof(keep) - 1); + } + send store, eGSealReq, (client = this, agen = agen, keep = keep, doSweep = cfg.toggles.sweep, genTable = genTable); + receive { + case eStoreAck: {} + case eStoreDead: { storeDead = true; } + } + if (storeDead) { goto DeadSched; } + send env, eGAttemptEnded, (sealed = true, failed = false); + goto DoneSched; + } + + // Pass staleness test. G9 compression admissibility: under + // stampCompression the pass sees FLOOR-BUCKETED stamps (buckets + // of 2) — lossy but STALE-erring, never false-live (safety + // preserved; extra redos are the recorded cost). The forced + // re-run lands on the bumped (even) generation, so the next scan + // converges. Stored stamps and the P6-S judge stay exact. + fun staleStamp(s: int, cur: int): bool { + if (cfg.stampCompression) { + return (s - s % 2) < cur; + } + return s < cur; + } + + fun nodeInFrontier(n: int): bool { + var i: int; + i = 0; + while (i < sizeof(frontier)) { + if (frontier[i].node == n) { return true; } + i = i + 1; + } + return false; + } + + fun forcedAlready(key: int, owners: map[int, int]): bool { + var i: int; + if (!(key in owners)) { return true; } // ownerless key: nothing to force + i = 0; + while (i < sizeof(frontier)) { + if (frontier[i].node == owners[key]) { return true; } + i = i + 1; + } + return false; + } + + // Final demand closure over CURRENT store content (the durable + // truth survives crashes): BFS from the cell's root keys along + // announced childHash references. + fun computeClosure(): seq[int] { + var out: seq[int]; + var queue: seq[int]; + var k: int; + var i: int; + var rows: seq[tGRow]; + var got: bool; + queue += (0, 0); // every scripted cell roots node 0 / key 0 + while (sizeof(queue) > 0) { + k = queue[0]; + queue -= 0; + if (inIntSeq(out, k)) { continue; } + out += (sizeof(out), k); + got = false; + send store, eGReadRowsReq, (client = this, agen = agen, key = k); + receive { + case eGReadRowsResp: (r: (rows: seq[tGRow], present: bool)) { + rows = r.rows; + got = true; + } + case eStoreDead: { storeDead = true; } + } + if (!got) { return out; } + i = 0; + while (i < sizeof(rows)) { + if (rows[i].childHash > 0 && !inIntSeq(out, rows[i].childHash - 1)) { + queue += (sizeof(queue), rows[i].childHash - 1); + } + i = i + 1; + } + } + return out; + } + + fun doCheckpoint(forced: bool) { + var ck: tGCkpt; + ck = buildCheckpoint(); + send store, eGCheckpointReq, (client = this, agen = agen, ck = ck, forced = forced); + receive { + case eStoreAck: {} + case eStoreDead: { storeDead = true; } + } + } + + // Checkpoint contents pinned by G-RULE-4: pending nodes (frontier + // + in-flight at their current generations), the admitted set, + // admitted-by edges, the generation table, the session index. + fun buildCheckpoint(): tGCkpt { + var pend: seq[tPendingNode]; + var ids: seq[int]; + var i: int; + pend = frontier; + ids = keys(outstanding); + i = 0; + while (i < sizeof(ids)) { + pend += (sizeof(pend), outstanding[ids[i]]); + i = i + 1; + } + return (pending = pend, admitted = admitted, edges = edges, genTable = genTable, readers = readers); + } + + fun rootFrontier() { + // Cell scripts: every cell roots the parent P (node 0). + genTable[0] = 1; + admitted[1] = true; + frontier += (0, (node = 0, kind = NK_PARENT, hash = 1, key = 0, gen = 1)); + } +} + +fun inIntSeq(s: seq[int], v: int): bool { + var i: int; + i = 0; + while (i < sizeof(s)) { + if (s[i] == v) { return true; } + i = i + 1; + } + return false; +} diff --git a/formal/graph/PSrc/Store.p b/formal/graph/PSrc/Store.p new file mode 100644 index 000000000..7992f9c94 --- /dev/null +++ b/formal/graph/PSrc/Store.p @@ -0,0 +1,447 @@ +/* MGStore: the durable store, one per scenario (SPEC 3/5). Holds the + artifact chain (partitions + manifest), unit markers (per-sync), + causal stamps (ride outputs), the session KV, poison flags, and the + frontier checkpoint. Crash protocol is walker parity: eCrash's + queue position partitions the dead attempt's outstanding ops; ops + behind it are dropped on arrival (agen check), never acked; + receivers get eStoreDead and park. + + Poison (SPEC 4b): a second DISTINCT derivation hash committing rows + for one key this sync poisons the key on its first hash-carrying + commit, voids the key's marker (R2-M8), and the eGAdopt refusal is + store-side (R3-M2). Post-poison rounds commit legally; the scope is + seal-excluded by the SealExpect exclusion and P1's exemption. */ + +type tSessCell = (val: int, writer: int, wgen: int); + +machine MGStore { + var prevPart: tGPart; + var prevMan: map[int, int]; + var curPart: tGPart; + var curMan: map[int, int]; + var curMarkers: map[int, tMarker]; + var curStamps: map[int, map[int, int]]; + var curOwners: map[int, int]; // key -> producing node (pass target) + var sessKV: map[int, tSessCell]; + var poisoned: map[int, bool]; + var firstHash: map[int, int]; // key -> first committed derivation hash this sync + var ckpt: tGCkpt; + var hasCkpt: bool; + var deadGens: map[int, bool]; + var syncN: int; + var sealed: bool; + var armed: bool; + var armedGen: int; + var armedClient: machine; + + start state Serving { + on eGReset do (p: (client: machine, syncN: int)) { + if (sealed) { + prevPart = curPart; + prevMan = curMan; + } + curPart = default(tGPart); + curMan = default(map[int, int]); + curMarkers = default(map[int, tMarker]); // markers are per-sync (SPEC 3) + curStamps = default(map[int, map[int, int]]); + curOwners = default(map[int, int]); + sessKV = default(map[int, tSessCell]); + poisoned = default(map[int, bool]); + firstHash = default(map[int, int]); + ckpt = default(tGCkpt); + hasCkpt = false; + sealed = false; + syncN = p.syncN; + send p.client, eStoreAck; + } + + on eGSwapPrev do (p: (client: machine, key: int, epoch: int)) { + // G3 between-attempt rebind (env scripting, no agen — no + // attempt is live): the PREV artifact's manifest and + // partition for the key become sibling content, so the + // resumed consult validates against the actually-current + // base and truthfully FAILs. + var rows: map[int, tGRow]; + rows[0] = (id = 0, epoch = p.epoch, hops = 0, childHash = 0, sVal = -1, sWriter = -1, sWGen = -1); + prevMan[p.key] = p.epoch; + prevPart[p.key] = rows; + send p.client, eStoreAck; + } + + on eGLookupReq do (p: (client: machine, agen: int, key: int)) { + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + if (p.key in prevMan) { + send p.client, eGLookupResp, (hit = true, v = prevMan[p.key]); + } else { + send p.client, eGLookupResp, (hit = false, v = -1); + } + } + + on eGMarkerReadReq do (p: (client: machine, agen: int, key: int)) { + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + if (p.key in curMarkers) { + send p.client, eGMarkerReadResp, (present = true, marker = curMarkers[p.key]); + } else { + send p.client, eGMarkerReadResp, (present = false, marker = default(tMarker)); + } + } + + on eGClearScope do (p: (client: machine, agen: int, key: int, delMarker: bool, ghost: tGGhost)) { + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + // Marker lifecycle rides the clear (R2-F4): the delete is + // announced BEFORE the clear so P-MARK sees the unbind + // first (one atomic op; markerCleanupOff removes this). + if (p.delMarker && p.key in curMarkers) { + curMarkers -= p.key; + announce eAnnMarkerDel, (syncN = syncN, key = p.key); + } + curPart[p.key] = default(map[int, tGRow]); + announce eAnnClear, (syncN = syncN, key = p.key, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eGUpsertPage do (p: (client: machine, agen: int, key: int, rows: seq[tGRow], ghost: tGGhost)) { + var i: int; + var dst: map[int, tGRow]; + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + if (p.key in curPart) { dst = curPart[p.key]; } + i = 0; + while (i < sizeof(p.rows)) { + dst[p.rows[i].id] = p.rows[i]; + i = i + 1; + } + curPart[p.key] = dst; + announce eAnnUpsert, (syncN = syncN, key = p.key, rows = p.rows, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eGPublishEntry do (p: (client: machine, agen: int, key: int, v: int, stamp: map[int, int], hash: int, ghost: tGGhost)) { + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + poisonCheck(p.key, p.hash); + curMan[p.key] = p.v; + curStamps[p.key] = p.stamp; + curOwners[p.key] = p.ghost.node; + announce eAnnPublish, (syncN = syncN, key = p.key, v = p.v, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eGReplayUnit do (p: (client: machine, agen: int, key: int, v: int, marker: tMarker, stamp: map[int, int], hash: int, ghost: tGGhost)) { + var ids: seq[int]; + var i: int; + var r: tGRow; + var dst: map[int, tGRow]; + var g: tGGhost; + var copied: seq[tGRow]; + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + // ONE atomic commit: marker (announced first, P-MARK + // convention), clear, copy, publish. Round completion IS + // unit commit; the publish constituent carries lastOp. + poisonCheck(p.key, p.hash); + g = p.ghost; + g.lastOp = false; + curMarkers[p.key] = p.marker; + announce eAnnMarkerPut, (syncN = syncN, key = p.key, node = p.marker.node, gen = p.marker.gen, roundId = p.marker.roundId, pubBearing = p.marker.pubBearing, contentEpoch = p.marker.contentEpoch, ghost = g); + curPart[p.key] = default(map[int, tGRow]); + announce eAnnClear, (syncN = syncN, key = p.key, ghost = g); + dst = curPart[p.key]; + if (p.key in prevPart) { + ids = keys(prevPart[p.key]); + i = 0; + while (i < sizeof(ids)) { + r = prevPart[p.key][ids[i]]; + r.hops = r.hops + 1; + dst[r.id] = r; + copied += (sizeof(copied), r); + i = i + 1; + } + } + curPart[p.key] = dst; + announce eAnnReplayCopy, (syncN = syncN, key = p.key, vBase = p.ghost.vBase, rows = copied, ghost = g); + curStamps[p.key] = p.stamp; + curOwners[p.key] = p.ghost.node; + curMan[p.key] = p.v; + announce eAnnPublish, (syncN = syncN, key = p.key, v = p.v, ghost = p.ghost); + send p.client, eGUnitResp, (rows = rowsOf(curPart, p.key),); + } + + on eGOverlayUnit do (p: (client: machine, agen: int, key: int, v: int, upserts: seq[tGRow], removes: seq[int], marker: tMarker, stamp: map[int, int], hash: int, composeDead: bool, ghost: tGGhost)) { + var ids: seq[int]; + var i: int; + var r: tGRow; + var dst: map[int, tGRow]; + var g: tGGhost; + var copied: seq[tGRow]; + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + poisonCheck(p.key, p.hash); + g = p.ghost; + g.lastOp = false; + curMarkers[p.key] = p.marker; + announce eAnnMarkerPut, (syncN = syncN, key = p.key, node = p.marker.node, gen = p.marker.gen, roundId = p.marker.roundId, pubBearing = p.marker.pubBearing, contentEpoch = p.marker.contentEpoch, ghost = g); + if (p.composeDead && p.key in curPart && sizeof(curPart[p.key]) > 0) { + // INJECT (G8b kill): compose the diff onto whatever the + // partition already holds — possibly a dead + // generation's partial debris — instead of the unit's + // clear + prev-copy base (the §4b precondition waived). + dst = curPart[p.key]; + announce eAnnReplayCopy, (syncN = syncN, key = p.key, vBase = p.ghost.vBase, rows = copied, ghost = g); + } else { + curPart[p.key] = default(map[int, tGRow]); + announce eAnnClear, (syncN = syncN, key = p.key, ghost = g); + dst = curPart[p.key]; + if (p.key in prevPart) { + ids = keys(prevPart[p.key]); + i = 0; + while (i < sizeof(ids)) { + r = prevPart[p.key][ids[i]]; + r.hops = r.hops + 1; + dst[r.id] = r; + copied += (sizeof(copied), r); + i = i + 1; + } + } + announce eAnnReplayCopy, (syncN = syncN, key = p.key, vBase = p.ghost.vBase, rows = copied, ghost = g); + } + i = 0; + while (i < sizeof(p.upserts)) { + dst[p.upserts[i].id] = p.upserts[i]; + i = i + 1; + } + announce eAnnUpsert, (syncN = syncN, key = p.key, rows = p.upserts, ghost = g); + i = 0; + while (i < sizeof(p.removes)) { + if (p.removes[i] in dst) { dst -= p.removes[i]; } + i = i + 1; + } + announce eAnnTombstones, (syncN = syncN, key = p.key, removes = p.removes, ghost = g); + curPart[p.key] = dst; + curStamps[p.key] = p.stamp; + curOwners[p.key] = p.ghost.node; + curMan[p.key] = p.v; + announce eAnnPublish, (syncN = syncN, key = p.key, v = p.v, ghost = p.ghost); + send p.client, eGUnitResp, (rows = rowsOf(curPart, p.key),); + } + + on eGAdoptReq do (p: (client: machine, agen: int, key: int, node: int, fromGen: int, toGen: int, roundId: int, allowLiveFrom: bool, ghost: tGGhost)) { + var m: tMarker; + var st: map[int, int]; + var outRows: seq[tGRow]; + var ids: seq[int]; + var i: int; + var deadFrom: bool; + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + // Store-side preconditions: marker present and not voided; + // key not poisoned (R3-M2); fromGen dead per the last + // durable generation table (R2-N1; allowLiveFrom is the + // suppressionOff declared deviation). + deadFrom = hasCkpt && p.node in ckpt.genTable && p.fromGen < ckpt.genTable[p.node]; + if (!(p.key in curMarkers) || curMarkers[p.key].voided || (p.key in poisoned) || (!deadFrom && !p.allowLiveFrom)) { + send p.client, eGAdoptResp, (ok = false, rows = outRows); + return; + } + m = curMarkers[p.key]; + m.gen = p.toGen; + m.roundId = p.ghost.roundId; + curMarkers[p.key] = m; + if (p.key in curStamps) { st = curStamps[p.key]; } + if (p.node in st) { st -= p.node; } + st[p.node] = p.toGen; + curStamps[p.key] = st; + if (p.key in curPart) { + ids = keys(curPart[p.key]); + i = 0; + while (i < sizeof(ids)) { + outRows += (sizeof(outRows), curPart[p.key][ids[i]]); + i = i + 1; + } + } + announce eAnnAdopt, (syncN = syncN, key = p.key, node = p.node, fromGen = p.fromGen, toGen = p.toGen, adoptedRoundId = p.roundId, rows = outRows, ghost = p.ghost); + send p.client, eGAdoptResp, (ok = true, rows = outRows); + } + + on eGSessionPub do (p: (client: machine, agen: int, skey: int, val: int, writer: int, wgen: int, ghost: tGGhost)) { + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + sessKV[p.skey] = (val = p.val, writer = p.writer, wgen = p.wgen); + announce eAnnSessionSet, (syncN = syncN, skey = p.skey, val = p.val, writer = p.writer, wgen = p.wgen, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eGSessionGetReq do (p: (client: machine, agen: int, reader: int, rgen: int, skey: int)) { + var c: tSessCell; + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + if (p.skey in sessKV) { + c = sessKV[p.skey]; + announce eAnnSessionRead, (syncN = syncN, reader = p.reader, rgen = p.rgen, skey = p.skey, found = true, val = c.val, writer = c.writer, wgen = c.wgen); + send p.client, eGSessionGetResp, (found = true, val = c.val, writer = c.writer, wgen = c.wgen); + } else { + announce eAnnSessionRead, (syncN = syncN, reader = p.reader, rgen = p.rgen, skey = p.skey, found = false, val = -1, writer = -1, wgen = -1); + send p.client, eGSessionGetResp, (found = false, val = -1, writer = -1, wgen = -1); + } + } + + on eGCheckpointReq do (p: (client: machine, agen: int, ck: tGCkpt, forced: bool)) { + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + ckpt = p.ck; + hasCkpt = true; + announce eAnnCheckpoint, (syncN = syncN, forced = p.forced); + send p.client, eStoreAck; + } + + on eGReadCkptReq do (p: (client: machine)) { + send p.client, eGReadCkptResp, (ck = ckpt, has = hasCkpt); + } + + on eGReadRowsReq do (p: (client: machine, agen: int, key: int)) { + var out: seq[tGRow]; + var ids: seq[int]; + var i: int; + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + if (p.key in curPart) { + ids = keys(curPart[p.key]); + i = 0; + while (i < sizeof(ids)) { + out += (sizeof(out), curPart[p.key][ids[i]]); + i = i + 1; + } + send p.client, eGReadRowsResp, (rows = out, present = true); + } else { + send p.client, eGReadRowsResp, (rows = out, present = false); + } + } + + on eGReadStampsReq do (p: (client: machine, agen: int)) { + maybeCrash(); + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + send p.client, eGReadStampsResp, (stamps = curStamps, owners = curOwners); + } + + on eGSealReq do (p: (client: machine, agen: int, keep: seq[int], doSweep: bool, genTable: map[int, int])) { + // Guaranteed resolution point for an armed crash (walker + // parity): fires either just before the seal or right after. + if (armed && armedGen == p.agen) { + if (choose(2) == 0) { + fireCrash(); + } else { + commitSeal(p.keep, p.doSweep, p.genTable); + send p.client, eStoreAck; + fireCrash(); + return; + } + } + if (p.agen in deadGens) { send p.client, eStoreDead; return; } + commitSeal(p.keep, p.doSweep, p.genTable); + send p.client, eStoreAck; + } + + on eReadSealedReq do (p: (client: machine)) { + send p.client, eReadSealedResp, (sealed = sealed,); + } + + on eCrashArm do (p: (client: machine, agen: int)) { + armed = true; + armedGen = p.agen; + armedClient = p.client; + send p.client, eCrashArmed; + } + } + + // Seal-time sweep (SPEC 3 seal sequence): drop partitions, + // manifest entries, and stamps for keys outside the final demand + // closure. Markers never travel into the sealed artifact (per-sync + // scoping pin) — modeled by curMarkers being sync-local state that + // eGReset discards. + fun commitSeal(keep: seq[int], doSweep: bool, genTable: map[int, int]) { + var ks: seq[int]; + var i: int; + if (doSweep) { + ks = keys(curPart); + i = 0; + while (i < sizeof(ks)) { + if (!inKeep(keep, ks[i])) { + curPart -= ks[i]; + if (ks[i] in curMan) { curMan -= ks[i]; } + if (ks[i] in curStamps) { curStamps -= ks[i]; } + } + i = i + 1; + } + ks = keys(curMan); + i = 0; + while (i < sizeof(ks)) { + if (!inKeep(keep, ks[i])) { + curMan -= ks[i]; + } + i = i + 1; + } + } + sealed = true; + announce eAnnGSeal, (syncN = syncN, partition = curPart, manifest = curMan, stamps = curStamps, genTable = genTable); + } + + fun inKeep(keep: seq[int], k: int): bool { + var i: int; + i = 0; + while (i < sizeof(keep)) { + if (keep[i] == k) { return true; } + i = i + 1; + } + return false; + } + + // Same-key distinct-derivation detection (SPEC 4b poison row): + // the second distinct hash's first hash-carrying commit poisons + // the key and VOIDS its marker (R2-M8). + fun poisonCheck(key: int, hash: int) { + var m: tMarker; + if (key in firstHash && firstHash[key] != hash) { + if (!(key in poisoned)) { + poisoned[key] = true; + if (key in curMarkers) { + m = curMarkers[key]; + m.voided = true; + curMarkers[key] = m; + } + announce eAnnPoison, (syncN = syncN, key = key); + } + return; + } + firstHash[key] = hash; + } + + fun maybeCrash() { + if (armed && choose(2) == 0) { + fireCrash(); + } + } + + fun rowsOf(part: tGPart, key: int): seq[tGRow] { + var out: seq[tGRow]; + var ids: seq[int]; + var i: int; + if (!(key in part)) { return out; } + ids = keys(part[key]); + i = 0; + while (i < sizeof(ids)) { + out += (sizeof(out), part[key][ids[i]]); + i = i + 1; + } + return out; + } + + fun fireCrash() { + deadGens[armedGen] = true; + armed = false; + announce eAnnCrash, (syncN = syncN,); + send armedClient, eCrashAck; + } +} diff --git a/formal/graph/PSrc/Types.p b/formal/graph/PSrc/Types.p new file mode 100644 index 000000000..0da353a3d --- /dev/null +++ b/formal/graph/PSrc/Types.p @@ -0,0 +1,241 @@ +/* Types for the demand-graph runtime model (deliverable 4). + Source of truth: formal/GRAPH_MODEL_SPEC.md (v4, FROZEN). + Small scope (SPEC 8): <=4 nodes, epochs 1..3, row ids 0..1, + <=3 syncs, <=3 attempts/sync, 2 workers, <=2 pages/round, + pass-iteration budget <=3. + + Identity conventions (build decision, logged in CALIBRATION.md): + nodes are ints 0..3; a node's output key = its node id; a node's + derivation hash = node id + 1 (so childHash 0 = "no child named"); + the G8c distinct-derivation-same-key shape overrides the key + mapping per cell. Generations are per-node monotone counters in + the scheduler table (G-RULE-3); attempt ids (store crash gating) + are syncN*10 + attempt, disjoint from node generations. */ + +// Node kinds: scripted execution bodies (SPEC 3 MNodeExec). +enum tNodeKind { NK_PARENT, NK_CONSULT, NK_WRITER, NK_READER } + +// Verdict classes (SPEC 3: ADOPT is a registered verdict class, +// round-2 R2-F3, alongside replay / changed-with-diff / fetch-fresh). +enum tGVerdict { GV_ADOPT, GV_REPLAY, GV_DIFF, GV_FRESH } + +// Lineage variants (SPEC 1: both first-class scheduler modes). +enum tLineage { LIN_E, LIN_S } + +// Session store variants (SPEC 3 MSessionStore). +enum tSessVar { SESS_A, SESS_B } + +// Consult/revalidation outcome (digest vocabulary, SPEC 4a). +// 0 = MISS, 1 = MATCH, 2 = FAIL — ints so digests compare with ==. + +// A stored row. epoch is the ghost content tag (truthful upstream), +// hops the P2 replay-travel counter, childHash the demand-derivation +// content (G-RULE-1: structure rides emissions; 0 = none), and the +// sess* triple the embedded session read (sVal -1 = none) for the +// P6-G value comparison. +type tGRow = (id: int, epoch: int, hops: int, childHash: int, sVal: int, sWriter: int, sWGen: int); + +// key -> row id -> row +type tGPart = map[int, map[int, tGRow]]; + +// Premise digest (SPEC 4a): canonical hash of the consult result +// (previous entry + revalidation outcome) and the identity+writer- +// stamp of every session value read before unit commit. One session +// read per node in every scripted cell (build decision). +type tDigest = (v: int, outcome: int, sVal: int, sWriter: int, sWGen: int, hasSess: bool); + +// Unit marker (SPEC 3/4a): per-sync store row. roundId identifies the +// marked round for P-MARK; contentEpoch is the marked round's output +// content tag (replay -> vBase, overlay -> consult epoch). +type tMarker = (node: int, gen: int, roundId: int, digest: tDigest, pubBearing: bool, voided: bool, contentEpoch: int); + +// A pending node on the frontier (G-RULE-4 checkpoint row). +type tPendingNode = (node: int, kind: tNodeKind, hash: int, key: int, gen: int); + +// Generation-qualified admitted-by edge (variant E lineage state, +// durable per G-RULE-4). +type tEdge = (parent: int, pgen: int); + +// Session read record (scheduler session index per variant; in the +// checkpoint per G-RULE-4). +type tReadRec = (reader: int, rgen: int, skey: int, val: int, writer: int, wgen: int); + +// Session publish record (worker completion report). +type tPub = (skey: int, val: int, wgen: int); + +// Frontier checkpoint (G-RULE-4, total): pending nodes, the +// admitted-derivation set, admitted-by edges, the generation table, +// the session index. Variant E support counts are derived (rebuild +// target = checkpoint-consistent value). +type tGCkpt = (pending: seq[tPendingNode], admitted: map[int, bool], edges: map[int, seq[tEdge]], genTable: map[int, int], readers: seq[tReadRec]); + +// Mitigation/mechanism toggles (SPEC 6). Positive names, default ON +// where the toggle REMOVES a mechanism (walker convention); the two +// injections (adoptOnFail, writerAdopt) default OFF. +type tGToggles = ( + suppression: bool, // G-RULE-2 admission suppression + sweep: bool, // seal-time sweep + sweepOverreach: bool, // INJECT: sweep drops an in-closure key + purge: bool, // E pending-purge on death (∀-predicate) + stampMerge: bool, // S read-side stamp merge + retraction: bool, // E+B re-publish reader retraction + overlayComposeDead: bool, // INJECT: overlay over a dead base + resumeCkpt: bool, // forced resume checkpoint (F4) + demandDrop: bool, // INJECT: drop one derived admission + adoptOnFail: bool, // INJECT: waive MATCH-only eligibility + writerAdopt: bool, // INJECT: waive writer-ineligibility + quiesce: bool, // quiesce-before-bump (R2-F1) + midBumpFence: bool, // mid-bump fence (R3-F2) + markerCleanup: bool // REPLACES clear deletes the marker (R2-F4) +); + +// Scenario configuration, built per test cell in PTst via +// defaultGCfg() + field overrides. +type tGCfg = ( + // Cell topology / script id: + // 11 = G1 family: parent P (node 0) -> consult node C (node 1); + // P's fresh rows all name C (double-announce premise). + // 21 = G2 family: P (node 0) -> writer H (node 2) + reader G + // (node 3); H publishes session key 0; G reads it (phase 2). + // 24 = G5 family: PAGINATED parent P (node 0) -> consult node C + // (node 1), named on P's page-1 row ONLY (the row the + // e1->e2 mutation deletes: upstream demand shrink). The + // mutation target is P's OWN scope (key 0). + // 25 = G3 (artifact swap + rebind): cell-11 topology; interrupt 1 + // stops C after its attempt-1 consult; the env swaps C's + // PREV artifact to sibling content between attempts. + // 26 = G6a/G6b (redo bake-off chain): P (node 0) -> S1 (node 1, + // names C on its page-1 row) -> C (node 4) -> GC (node 5). + // G6b mutates S1's scope (key 1) between attempts: the + // descendant chain's demand shrinks. + // 27 = G7 (progress under churn): cell-11 topology; node 1 fails + // LOUD deterministically in failSync (generation-blind + // fingerprint; the abandon ladder is cfg.ladder). + // 28 = G6c (fan-in): P names S1 (node 1) + S2 (node 4); BOTH name + // C (node 5) — two admitted-by edges; a crash killing one + // parent must not purge/refuse C on the survivor's live edge. + // 29 = G8c (same-key distinct-derivation): P names node 1 AND + // node 4; keyOf maps BOTH to output key 1 (distinct hashes, + // one key) — the store poisons on the second derivation's + // first commit. + cell: int, + lineage: tLineage, + sessVar: tSessVar, + // Interruption script: 0 = none; 1 = graceful stop at C's + // attempt-1 consult (G3: stop-forced checkpoint, store intact); + // 2 = hard crash in attempt 1 of interruptSync; 3 = hard crash + // in attempts 1 AND 2 (two-crash cells: G1b, G1e, G8d). + interrupt: int, + interruptSync: int, + nSyncs: int, + mutateBetweenSyncs: bool, // key 1: e1 -> e2 after sync 1 + mutateBetweenAttempts: bool, // key 1: +1 between attempts of interruptSync + // Connector policy (verdicts are connector choice, walker + // precedent): FAIL verdict yields CHANGED-WITH-DIFF unit when + // diffPolicy, else fetch-fresh record round; a re-derivation + // after an ineligible/failed marker check uses fetch-fresh when + // rederiveFresh (the G1(ii)/G1c scripted shape). + diffPolicy: bool, + rederiveFresh: bool, + // Worker pool size (SPEC 8 budget: 2). The G1d cell scripts 3 so + // the retraction-forced re-run can dispatch AT the bump instead + // of waiting for a completion to free a worker — with 2, the + // dying-reader race needs two long starvation phases and random + // search cannot reach it (calibration find, logged). + nWorkers: int, + // Content flap-back (G2 flap-back probe, G8d): raw epoch >= 3 + // serves content identical to epoch 1; the upstream reports + // CONTENT epochs everywhere (raw epochs never escape it), so + // validators, manifests, expectations, and folds stay coherent. + flapBack: bool, + // G6 bake-off count oracle: max executions per node per sync + // (0 = unmonitored). The minimal GREEN bound is the + // checker-verified worst-case redo count for the leg. + execBound: int, + // G7 loud-failure script: failNode fails deterministically at + // execution start in failSync (-1 = none). The abandon ladder + // (abandon after 2 identical generation-blind fingerprints) is + // the proposed machinery; ladder=false is the P4-STUCK kill. + failNode: int, + failSync: int, + ladder: bool, + // G9 compression admissibility: the S pre-seal pass compares + // FLOOR-BUCKETED stamps (buckets of 2) — lossy but stale-erring + // (never false-live); forced re-runs land on the bumped (even) + // generation, so the pass still converges. Stored stamps and + // monitors stay exact: the claim is about mechanism decisions. + stampCompression: bool, + // G5d meta-analysis (GS-CO-005(d)): when non-empty, the env + // announces this map as the GSEALWORLD probe target for + // interruptSync's seal (world = manifest restricted to keys + // sealing non-empty partitions). Empty = probe disarmed. + sealWorld: map[int, int], + toggles: tGToggles +); + +fun defaultGToggles(): tGToggles { + return ( + suppression = true, + sweep = true, + sweepOverreach = false, + purge = true, + stampMerge = true, + retraction = true, + overlayComposeDead = false, + resumeCkpt = true, + demandDrop = false, + adoptOnFail = false, + writerAdopt = false, + quiesce = true, + midBumpFence = true, + markerCleanup = true + ); +} + +fun defaultGCfg(): tGCfg { + return ( + cell = 11, + lineage = LIN_E, + sessVar = SESS_A, + interrupt = 0, + interruptSync = 2, + nSyncs = 2, + mutateBetweenSyncs = false, + mutateBetweenAttempts = false, + diffPolicy = false, + rederiveFresh = false, + nWorkers = 2, + flapBack = false, + execBound = 0, + failNode = -1, + failSync = 0, + ladder = true, + stampCompression = false, + sealWorld = default(map[int, int]), + toggles = defaultGToggles() + ); +} + +// Round ghost carried on store ops for the monitors (walker parity; +// node/gen added for P-GEN attribution, vBase for the fold). +type tGGhost = (roundId: int, verdict: tGVerdict, consultEpoch: int, vBase: int, lastOp: bool, attempt: int, node: int, gen: int); + +// Node kind script (shared by scheduler re-admissions and env roots). +fun kindOf(cell: int, node: int): tNodeKind { + if (node == 0) { return NK_PARENT; } + if (node == 2) { return NK_WRITER; } + if (node == 3) { return NK_READER; } + return NK_CONSULT; +} + +// Output-key script: key = node id everywhere EXCEPT the same-key +// distinct-derivation cell (G8c), where node 4 shares node 1's +// output key — distinct hashes, one key, the poison row's premise. +fun keyOf(cell: int, node: int): int { + if (cell == 29 && node == 4) { return 1; } + return node; +} + +// Worker completion report payload (the carrier announce whose atomic +// processing hosts all derived effects, G-RULE-1). +type tGReport = (execId: int, node: int, gen: int, hash: int, key: int, kind: tNodeKind, verdict: tGVerdict, rows: seq[tGRow], pubs: seq[tPub], reads: seq[tReadRec], aborted: bool); diff --git a/formal/graph/PSrc/Upstream.p b/formal/graph/PSrc/Upstream.p new file mode 100644 index 000000000..781ea80fd --- /dev/null +++ b/formal/graph/PSrc/Upstream.p @@ -0,0 +1,111 @@ +/* MGUpstream: the external system of record (walker parity). + Truthful: a validator (content-epoch-valued) validates iff its + content equals the current content. Row table: epoch 1 has rows + {0,1}; epoch >= 2 has {0} (row 1 deleted at the e1->e2 mutation), + so unions and resurrections are content-visible with 2 row ids. + + FLAP-BACK (G2 flap-back probe, G8d): with cfg.flapBack, raw epoch + >= 3 serves content identical to epoch 1. The upstream reports + CONTENT epochs everywhere — validate responses, fetched rows, diff + pages — so raw epochs never escape it and every downstream consumer + (markers, manifests, folds, SealExpect worlds) stays coherent. */ + +fun upstreamRowIds(epoch: int): seq[int] { + var ids: seq[int]; + ids += (0, 0); + if (epoch <= 1) { + ids += (1, 1); + } + return ids; +} + +// rows(k, e) as id -> content-epoch map (monitor-side fold table). +fun rowsAt(epoch: int): map[int, int] { + var ids: seq[int]; + var m: map[int, int]; + var i: int; + ids = upstreamRowIds(epoch); + i = 0; + while (i < sizeof(ids)) { + m[ids[i]] = epoch; + i = i + 1; + } + return m; +} + +machine MGUpstream { + var epochs: map[int, int]; // key -> current RAW epoch + var flapBack: bool; + + start state Serving { + entry (p: (flapBack: bool)) { + flapBack = p.flapBack; + epochs[0] = 1; + epochs[1] = 1; + epochs[2] = 1; + epochs[3] = 1; + epochs[4] = 1; + epochs[5] = 1; + } + + on eValidateReq do (p: (client: machine, scope: int, v: int)) { + send p.client, eValidateResp, (ok = p.v == contentEpoch(p.scope), epoch = contentEpoch(p.scope)); + } + + on eFetchReq do (p: (client: machine, scope: int, page: int)) { + var ids: seq[int]; + var rows: seq[tGRow]; + var e: int; + e = contentEpoch(p.scope); + ids = upstreamRowIds(e); + if (p.page < sizeof(ids)) { + rows += (0, (id = ids[p.page], epoch = e, hops = 0, childHash = 0, sVal = -1, sWriter = -1, sWGen = -1)); + } + // Fixed 2-page rounds (pages per key per round <= 2). + send p.client, eFetchResp, (rows = rows, epoch = e, morePages = p.page == 0); + } + + on eDiffReq do (p: (client: machine, scope: int, fromEpoch: int, page: int)) { + var e: int; + var ups: seq[tGRow]; + var rms: seq[int]; + var fromIds: seq[int]; + var toIds: seq[int]; + var i: int; + e = contentEpoch(p.scope); + // Truthful total diff from the base content to the current + // content: page 0 upserts (every current row when content + // differs), page 1 removes (base rows absent now). + if (p.page == 0) { + if (p.fromEpoch != e) { + toIds = upstreamRowIds(e); + i = 0; + while (i < sizeof(toIds)) { + ups += (sizeof(ups), (id = toIds[i], epoch = e, hops = 0, childHash = 0, sVal = -1, sWriter = -1, sWGen = -1)); + i = i + 1; + } + } + } else { + fromIds = upstreamRowIds(p.fromEpoch); + i = 0; + while (i < sizeof(fromIds)) { + if (!(fromIds[i] in rowsAt(e))) { + rms += (sizeof(rms), fromIds[i]); + } + i = i + 1; + } + } + send p.client, eDiffResp, (upserts = ups, removes = rms, epoch = e, morePages = p.page == 0); + } + + on eMutate do (p: (client: machine, scope: int)) { + epochs[p.scope] = epochs[p.scope] + 1; + send p.client, eMutateAck; + } + } + + fun contentEpoch(scope: int): int { + if (flapBack && epochs[scope] >= 3) { return 1; } + return epochs[scope]; + } +} diff --git a/formal/graph/PTst/ScenarioG1.p b/formal/graph/PTst/ScenarioG1.p new file mode 100644 index 000000000..9ac5b67f3 --- /dev/null +++ b/formal/graph/PTst/ScenarioG1.p @@ -0,0 +1,167 @@ +/* G1 family — phantom-union premises under the graph runtime + (SPEC 9). Topology cell 11: parent P (node 0, fetch-fresh, every + row names C) -> consult node C (node 1, marker machinery). + Expected verdicts (declared before first run): + - tcG1i_All: leg (i) crash-before/around-commit, fetch-fresh + policy (diffPolicy off), e1->e2 between syncs — GREEN all. + - tcG1ii_All: leg (ii) diff unit + crash + e2->e3 between + attempts, re-derive fetch-fresh (MATCH-only forces re-derive; + record REPLACES deletes the marker) — GREEN all. (Also the G1c + honest chassis.) + - tcG1iii_E / tcG1iii_S: leg (iii) crash-after-commit, no + mutation — MATCH, digest equal, writer bit clear -> ADOPT — + GREEN all, both lineage variants. + - tcG1sup_P1: suppressionOff on the leg-(iii) chassis — + P1-LEGALITY first-find on the racing double-admission schedule + (sequential schedules adopt under the declared live-fromGen + deviation, R2-N1). RED. + - tcG1b_All: two-crash generation-reuse probe, honest — GREEN + (forced resume checkpoint fences resume minting, F4). + - tcG1bMut_PGEN: resumeCkptOff — P-GEN RED (attempts 2 and 3 + re-mint one generation from the stale table). + - tcG1c_All: FAIL-adopt probe honest (same chassis as leg (ii)): + MATCH-only forces re-derive, fetch reflects e3 — GREEN. + - tcG1cMut_Adopt: adoptOnFail — adopts rows(e2) after a FAIL + consult — P-ADOPT RED. (Calibration find G1-CAL-1 moved this + kill off SealExpect: completed-across-crash schedules seal + attempt-1 content honestly under sync-scoped freshness, so the + scripted expectation accepts any attempt-start world and the + FAIL-adopt laundering is only mechanism-visible.) + - tcG1cMut_P3: adoptOnFail — GP3prime stays GREEN (the FAIL + re-consult does not qualify; the last qualifying verdict is + attempt 1's diff at e2, which expects the mutant's own rows — + the adopt-legality monitor is the only oracle that flips). */ + +machine TestG1i { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 2; + c.mutateBetweenSyncs = true; + new MGEnv(c); + } + } +} + +machine TestG1ii { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 2; + c.mutateBetweenSyncs = true; + c.mutateBetweenAttempts = true; + c.diffPolicy = true; + c.rederiveFresh = true; + new MGEnv(c); + } + } +} + +machine TestG1iiiE { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 2; + new MGEnv(c); + } + } +} + +machine TestG1iiiS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 2; + c.lineage = LIN_S; + new MGEnv(c); + } + } +} + +machine TestG1sup { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 2; + t = defaultGToggles(); + t.suppression = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG1b { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 3; + new MGEnv(c); + } + } +} + +machine TestG1bMut { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 3; + t = defaultGToggles(); + t.resumeCkpt = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG1cMut { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 11; + c.interrupt = 2; + c.mutateBetweenSyncs = true; + c.mutateBetweenAttempts = true; + c.diffPolicy = true; + c.rederiveFresh = true; + t = defaultGToggles(); + t.adoptOnFail = true; + c.toggles = t; + new MGEnv(c); + } + } +} + +module Graph = { MGEnv, MGStore, MGUpstream, MGraphSched, MGNodeExec }; + +// Expected GREEN: +test tcG1i_All [main=TestG1i]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG in (union Graph, { TestG1i }); +test tcG1ii_All [main=TestG1ii]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG in (union Graph, { TestG1ii }); +test tcG1iii_E [main=TestG1iiiE]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG in (union Graph, { TestG1iiiE }); +test tcG1iii_S [main=TestG1iiiS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6S, GPASS in (union Graph, { TestG1iiiS }); +test tcG1b_All [main=TestG1b]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG in (union Graph, { TestG1b }); +test tcG1cMut_P3 [main=TestG1cMut]: assert GP3prime in (union Graph, { TestG1cMut }); +test tcG1cMut_Seal [main=TestG1cMut]: assert SealExpectG in (union Graph, { TestG1cMut }); + +// Expected RED (counterexample = the calibration find): +test tcG1sup_P1 [main=TestG1sup]: assert GP1 in (union Graph, { TestG1sup }); +test tcG1bMut_PGEN [main=TestG1bMut]: assert PGEN in (union Graph, { TestG1bMut }); +test tcG1cMut_Adopt [main=TestG1cMut]: assert PADOPT in (union Graph, { TestG1cMut }); diff --git a/formal/graph/PTst/ScenarioG2.p b/formal/graph/PTst/ScenarioG2.p new file mode 100644 index 000000000..40ef2ee2b --- /dev/null +++ b/formal/graph/PTst/ScenarioG2.p @@ -0,0 +1,324 @@ +/* G2 family — session laundering (SPEC 9), plus the G1d/G1e probes + that ride the session chassis. Topology cell 21: parent P (node 0, + row 0 names writer H = node 2, row 1 names reader G = node 3). H + publishes session key 0 (value = its consult epoch: same-premise + re-derivations re-publish the same value); G reads it and embeds + the value in its rows. + + Common chassis: 2 syncs, crash in sync 2 attempt 1. The LAUNDERING + legs mutate H's scope between attempts so H's re-publish value + differs; the ANNOUNCE-WINDOW / flap-back legs are premise-stable + (no mutation) so adoption eligibility and same-value re-publish + are reachable. + + Expected verdicts (declared before first run): + - tcG2ea_P6G: E + session variant A — THE FINDING: no retraction, + no stamps; a schedule where G completed (+ckpt) before the + crash and H re-published a different value seals G's rows + embedding the dead value — P6-G RED. + - tcG2ea_Core: same cell, artifact-level monitors only — GREEN + (the laundering is invisible to P1/P2/P3'/SealExpect: the + blindness contrast is the point). + - tcG2eb_All: E + variant B (retraction + quiesce) — GREEN all + (incl. P6-G, P6-E). + - tcG2ebRetrOff_P6G: retractionOff — P6-G RED. + - tcG2s_All: S (stamps + pre-seal pass) — GREEN all (incl. P6-S). + - tcG2sStampOff_P6G: stampMergeOff — P6-G RED (the pass never + sees the dead writer stamp on G's output). + - tcG2awE_All / tcG2awS_All: announce-window + writer flap-back + honest legs (premise-stable): H's publish-bearing marker is + adoption-INELIGIBLE -> REPLAY re-derive -> re-publish same + value under the new generation -> readers cleared (retraction / + stamp delta) — GREEN all. + - tcG2awE_Redo / tcG2awS_Redo: REDO-PROBE existence exhibits on + the same chassis — RED (the at-least-once cost is real: a + forced reader redo exists). + - tcG2awWA_E: writerAdopt — H adopts, never re-publishes; the + dead-generation publish strands; G is never retracted — P6-E + RED. (P6-G stays green: the value is unchanged — the kill is + mechanism-visible only.) + - tcG2awWA_S: writerAdopt — G's re-reads keep merging the dead + {H: g1} stamp; the pass exhausts its budget — P6-S RED. + - tcG1d_P6G: E+B chassis + quiesceOff (round-2 R2-F1): the + retraction bump lands while the dying reader executes; the dead + execution's late record round overwrites the live re-derivation + — P6-G RED. Honest quiesce covered by tcG2eb_All. + - tcG2eb2c_All: honest two-crash session chassis — GREEN. + - tcG1e_PGEN: two crashes + midBumpFenceOff (round-3 R3-F2) — + P-GEN RED (generation identity reuse; the first-find may fire + on the first-admission mint path, which rides the same toggle + per GS-CO-001 — same discipline, same monitor). + - tcG2fbE_All / tcG2fbS_All: WRITER FLAP-BACK PROBE (round-3 + R3-F1's second registration): sync-2 attempt 1 commits H's + DIFF-verdict publish-bearing unit (d2, marker digest FAIL); + crash in the announce window; upstream flaps back + (content(e3) = content(e1)). Resume: H ineligible + (pubBearing + digest delta) -> re-derives -> re-consult vs the + PREV artifact (V1) MATCHes truthfully -> REPLAY verdict -> the + body-op pin re-publishes d1@g2 anyway -> readers cleared + (retraction / stamp delta) -> GREEN all. Under an elision + reading this history strands d2@g1 and reds P6-G/P6-S honestly + — the probe is the body-op pin's load-bearing witness. + - tcG2fbE_Redo: REDO-PROBE RED on the flap-back chassis (the + forced reader redo exists — the declared expected count >= 1). + - tcG2ebPend_Redo: REDO-PROBE RED on the honest E+B laundering + chassis — the G-pending re-retraction clause (R2-M6(i), + GS-CO-004's catch-up + re-publish paths) actually fires. */ + +machine TestG2ea { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_A; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MGEnv(c); + } + } +} + +machine TestG2eb { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MGEnv(c); + } + } +} + +machine TestG2ebRetrOff { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + t = defaultGToggles(); + t.retraction = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG2s { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MGEnv(c); + } + } +} + +machine TestG2sStampOff { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + t = defaultGToggles(); + t.stampMerge = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG2awE { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 2; + new MGEnv(c); + } + } +} + +machine TestG2awS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_S; + c.interrupt = 2; + new MGEnv(c); + } + } +} + +machine TestG2awWAE { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 2; + t = defaultGToggles(); + t.writerAdopt = true; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG2awWAS { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_S; + c.interrupt = 2; + t = defaultGToggles(); + t.writerAdopt = true; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG1d { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.nWorkers = 3; + t = defaultGToggles(); + t.quiesce = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG2eb2c { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 3; + c.mutateBetweenAttempts = true; + new MGEnv(c); + } + } +} + +machine TestG2fbE { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 2; + c.mutateBetweenSyncs = true; + c.mutateBetweenAttempts = true; + c.flapBack = true; + c.diffPolicy = true; + new MGEnv(c); + } + } +} + +machine TestG2fbS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenSyncs = true; + c.mutateBetweenAttempts = true; + c.flapBack = true; + c.diffPolicy = true; + new MGEnv(c); + } + } +} + +machine TestG1e { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_E; + c.sessVar = SESS_B; + c.interrupt = 3; + c.mutateBetweenAttempts = true; + t = defaultGToggles(); + t.midBumpFence = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +// Expected GREEN: +test tcG2ea_Core [main=TestG2ea]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG in (union Graph, { TestG2ea }); +test tcG2eb_All [main=TestG2eb]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6E in (union Graph, { TestG2eb }); +test tcG2s_All [main=TestG2s]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6S, GPASS in (union Graph, { TestG2s }); +test tcG2awE_All [main=TestG2awE]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6E in (union Graph, { TestG2awE }); +test tcG2awS_All [main=TestG2awS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6S, GPASS in (union Graph, { TestG2awS }); +test tcG2eb2c_All [main=TestG2eb2c]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6E in (union Graph, { TestG2eb2c }); +test tcG2fbE_All [main=TestG2fbE]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6E in (union Graph, { TestG2fbE }); +test tcG2fbS_All [main=TestG2fbS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6S, GPASS in (union Graph, { TestG2fbS }); + +// Expected RED: +test tcG2ea_P6G [main=TestG2ea]: assert GP6G in (union Graph, { TestG2ea }); +test tcG2ebRetrOff_P6G [main=TestG2ebRetrOff]: assert GP6G in (union Graph, { TestG2ebRetrOff }); +test tcG2sStampOff_P6G [main=TestG2sStampOff]: assert GP6G in (union Graph, { TestG2sStampOff }); +test tcG2awE_Redo [main=TestG2awE]: assert REDOPROBE in (union Graph, { TestG2awE }); +test tcG2awS_Redo [main=TestG2awS]: assert REDOPROBE in (union Graph, { TestG2awS }); +test tcG2fbE_Redo [main=TestG2fbE]: assert REDOPROBE in (union Graph, { TestG2fbE }); +test tcG2ebPend_Redo [main=TestG2eb]: assert REDOPROBE in (union Graph, { TestG2eb }); +test tcG2awWA_E [main=TestG2awWAE]: assert GP6E in (union Graph, { TestG2awWAE }); +test tcG2awWA_S [main=TestG2awWAS]: assert GP6S in (union Graph, { TestG2awWAS }); +test tcG1d_P6G [main=TestG1d]: assert GP6G in (union Graph, { TestG1d }); +// Existence probe: the forced reader redo arms on the G1d chassis +// (the reachability ladder's first rung; see CALIBRATION G1D-REACH). +test tcG1dProbe_Redo [main=TestG1d]: assert REDOPROBE in (union Graph, { TestG1d }); +test tcG1e_PGEN [main=TestG1e]: assert PGEN in (union Graph, { TestG1e }); diff --git a/formal/graph/PTst/ScenarioG3.p b/formal/graph/PTst/ScenarioG3.p new file mode 100644 index 000000000..f1db0a416 --- /dev/null +++ b/formal/graph/PTst/ScenarioG3.p @@ -0,0 +1,54 @@ +/* G3 — artifact swap + rebind (walker case 3 premise re-run; + confirmation cells, round-1 walked clean). Topology cell 25 = + cell-11 shape: parent P (node 0) names consult node C (node 1) on + every row. + + Script: 2 syncs, graceful stop (interrupt 1) in sync 2 — C's + attempt-1 execution stops AFTER its consult announce (MATCH + verdict pending, nothing committed; the stop-forced checkpoint + captures C pending at its consult-granularity cursor). Between + attempts the env swaps C's PREV artifact to sibling content + (epoch 9). Resume bumps the stopped generation (g1 dies with no + commits); the re-consult hits the ACTUALLY current (swapped) base, + truthfully FAILs validation, and falls to fetch-fresh; the + 3-atomic closure carries over from the walker. + + nWorkers = 1: serial execution, so the stop leaves no straggler + worker racing late commits into the stopped attempt's agen. + + Expected GREEN on both variants — the graph adds generation death + of the stopped execution to the walker's case-3 premise, and + nothing reds: no marker was written (stop precedes the round), no + adoption is offered, SealExpect binds the live world. */ + +machine TestG3E { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 25; + c.lineage = LIN_E; + c.interrupt = 1; + c.nWorkers = 1; + new MGEnv(c); + } + } +} + +machine TestG3S { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 25; + c.lineage = LIN_S; + c.interrupt = 1; + c.nWorkers = 1; + new MGEnv(c); + } + } +} + +// Expected GREEN: +test tcG3_E [main=TestG3E]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH in (union Graph, { TestG3E }); +test tcG3_S [main=TestG3S]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GP6S, GPASS in (union Graph, { TestG3S }); diff --git a/formal/graph/PTst/ScenarioG5.p b/formal/graph/PTst/ScenarioG5.p new file mode 100644 index 000000000..e974fe582 --- /dev/null +++ b/formal/graph/PTst/ScenarioG5.p @@ -0,0 +1,183 @@ +/* G5 family — sweep, purge, and the closure oracle (SPEC 9, round-1 + F5/F6/F8 re-scripts). Topology cell 24: PAGINATED parent P (node + 0, 2-page record round) names consult node C (node 1) on its + page-1 row ONLY — the row the e1->e2 mutation deletes. The + mutation target is P's OWN scope (key 0), so an attempt-2 + re-execution emits NO child naming: upstream demand shrink. + + The per-announce demand note (G-RULE-1 TIMING PIN) is the family's + load-bearing mechanism: P's page-1 commit admits C mid-round, so a + checkpoint can capture C-pending AND P-pending — the window the + resume ∀-purge (R2-F5) exists for. Carrier-only derivation makes + every shape below unreachable (calibration find; the spec pinned + per-announce timing from the start). + + Shrink chassis (mutateBetweenAttempts on key 0, crash in sync 2): + - tcG5aE_All / tcG5aS_All: honest sweep, both variants — GREEN. + Which parent world survives is schedule-dependent (sync-scoped + freshness): P re-ran at e2 -> C purged (E) or refused (S) or + never admitted, C's debris swept, seal {0}; P completed at e1 -> + C is live demand, seal {0, 1}. C's key is EXCLUDED from the + attempt-2 expectation (the structural question is GP5's). + - tcG5bE_P5 / tcG5bS_P5: sweepOff — the P-re-ran schedule seals + C's partition with no living namer — P5-UNDER RED both variants. + - tcG5e_Probe: PURGE-PROBE existence exhibit on the honest E + chassis — RED (the resume purge fires; the counterexample + exhibits the mid-round checkpoint window). + - tcG5e_PurgeOff: purgeOff (E) — the restored C dispatches with + every admitted-by edge dead — DEAD-DISPATCH RED (the G5e count + oracle: dead demand executed). + + No-shrink chassis (same cell, no mutation, crash in sync 2): + - tcG5f_All: honest — GREEN. The R2-F5 no-starvation witness: the + mid-round window purges C at resume, P's live re-derivation at + the SAME epoch re-names it, the purged hash is re-admissible + (G-RULE-2 removal), C re-runs, seal {0, 1}. Starvation would + red SealExpect (expected key missing). + - tcG5f_Drop: demandDropOff — one derived admission silently + dropped; P's sealed rows name a child that never ran — + P5-OVER / SEAL-EXPECT RED (the closure oracle's kill). + - tcG5c_P5: sweepOverreach — the seal drops an in-closure key; + the sealed parent still names it — P5-OVER RED. */ + +machine TestG5aE { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MGEnv(c); + } + } +} + +machine TestG5aS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MGEnv(c); + } + } +} + +machine TestG5bE { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + t = defaultGToggles(); + t.sweep = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG5bS { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + t = defaultGToggles(); + t.sweep = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG5eOff { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + t = defaultGToggles(); + t.purge = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG5f { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + new MGEnv(c); + } + } +} + +machine TestG5fDrop { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + t = defaultGToggles(); + t.demandDrop = true; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG5c { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + t = defaultGToggles(); + t.sweepOverreach = true; + c.toggles = t; + new MGEnv(c); + } + } +} + +// Expected GREEN: +test tcG5aE_All [main=TestG5aE]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH in (union Graph, { TestG5aE }); +test tcG5aS_All [main=TestG5aS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GPASS in (union Graph, { TestG5aS }); +test tcG5f_All [main=TestG5f]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH in (union Graph, { TestG5f }); + +// Expected RED: +test tcG5bE_P5 [main=TestG5bE]: assert GP5 in (union Graph, { TestG5bE }); +test tcG5bS_P5 [main=TestG5bS]: assert GP5 in (union Graph, { TestG5bS }); +test tcG5c_P5 [main=TestG5c]: assert GP5 in (union Graph, { TestG5c }); +test tcG5e_Probe [main=TestG5aE]: assert PURGEPROBE in (union Graph, { TestG5aE }); +test tcG5e_PurgeOff [main=TestG5eOff]: assert GDEADDISPATCH in (union Graph, { TestG5eOff }); +test tcG5f_Drop [main=TestG5fDrop]: assert SealExpectG, GP5 in (union Graph, { TestG5fDrop }); diff --git a/formal/graph/PTst/ScenarioG5d.p b/formal/graph/PTst/ScenarioG5d.p new file mode 100644 index 000000000..c3459891e --- /dev/null +++ b/formal/graph/PTst/ScenarioG5d.p @@ -0,0 +1,137 @@ +/* G5d — cross-variant seal-world meta-analysis (GS-CO-005(d)). + The honest shrink chassis (cell 24, crash in sync 2, key-0 + mutation between attempts) admits MULTIPLE legitimate sealed + worlds under sync-scoped freshness; the meta-analysis compares + the REACHABLE world sets across lineage variants via GSEALWORLD + existence probes (RED = the target world is reachable). + + Declared (before run, both variants): + - W1 = {0->2}: P re-ran at e2, C's demand shrank away, C swept + (E: purge / S: refusal / or never admitted) — REACHABLE, RED. + - W2 = {0->1, 1->1}: P completed-across-crash at e1 (G-RULE-2), + C live demand — REACHABLE, RED. + - W3 = {0->2, 1->1}: the sweep-failure world (P's e2 rows name no + C, yet C's partition seals) — UNREACHABLE, GREEN. The W1/W2 + REDs on the same chassis are the positive controls against a + vacuous GREEN here; the sweepOff kill (tcG5bE_P5/tcG5bS_P5, + P5-UNDER) is the registered mechanism-off contrast. + + A world reachable under exactly ONE variant is a divergence + finding and blocks Axis-3 citation (GS-CO-005(d)). */ + +machine TestG5dEW1 { + start state I { + entry { + var c: tGCfg; + var w: map[int, int]; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + w[0] = 2; + c.sealWorld = w; + new MGEnv(c); + } + } +} + +machine TestG5dSW1 { + start state I { + entry { + var c: tGCfg; + var w: map[int, int]; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + w[0] = 2; + c.sealWorld = w; + new MGEnv(c); + } + } +} + +machine TestG5dEW2 { + start state I { + entry { + var c: tGCfg; + var w: map[int, int]; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + w[0] = 1; + w[1] = 1; + c.sealWorld = w; + new MGEnv(c); + } + } +} + +machine TestG5dSW2 { + start state I { + entry { + var c: tGCfg; + var w: map[int, int]; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + w[0] = 1; + w[1] = 1; + c.sealWorld = w; + new MGEnv(c); + } + } +} + +machine TestG5dEW3 { + start state I { + entry { + var c: tGCfg; + var w: map[int, int]; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + w[0] = 2; + w[1] = 1; + c.sealWorld = w; + new MGEnv(c); + } + } +} + +machine TestG5dSW3 { + start state I { + entry { + var c: tGCfg; + var w: map[int, int]; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + w[0] = 2; + w[1] = 1; + c.sealWorld = w; + new MGEnv(c); + } + } +} + +// Declared RED (reachable worlds; the probe mechanism's positive +// controls for the W3 GREEN): +test tcG5dE_W1 [main=TestG5dEW1]: assert GSEALWORLD in (union Graph, { TestG5dEW1 }); +test tcG5dS_W1 [main=TestG5dSW1]: assert GSEALWORLD in (union Graph, { TestG5dSW1 }); +test tcG5dE_W2 [main=TestG5dEW2]: assert GSEALWORLD in (union Graph, { TestG5dEW2 }); +test tcG5dS_W2 [main=TestG5dSW2]: assert GSEALWORLD in (union Graph, { TestG5dSW2 }); + +// Declared GREEN (the sweep-failure world is unreachable honestly): +test tcG5dE_W3 [main=TestG5dEW3]: assert GSEALWORLD in (union Graph, { TestG5dEW3 }); +test tcG5dS_W3 [main=TestG5dSW3]: assert GSEALWORLD in (union Graph, { TestG5dSW3 }); diff --git a/formal/graph/PTst/ScenarioG6.p b/formal/graph/PTst/ScenarioG6.p new file mode 100644 index 000000000..65072bcdf --- /dev/null +++ b/formal/graph/PTst/ScenarioG6.p @@ -0,0 +1,274 @@ +/* G6 — redo-work bake-off (METRIC cells; the verdicts are counts, + not pass/fail; adequacy §10.1 count-oracle kills). The count + oracle is GEXECBOUND: executions per node per sync <= cfg.execBound + (announced at init). The minimal GREEN bound is the + checker-verified worst-case redo for the leg; the bound-minus-one + RED probe is the existence exhibit that the redo is real. The + bake-off table (CALIBRATION.md) is emitted from these verdicts. + + G6a (cell 26 chain, crash sync 2, re-derivation IDENTICAL): P -> + S1 -> C -> GC; per-announce demand notes admit the chain mid-round, + so a checkpoint can capture completed descendants under a pending + S1 — the divergence script from round-1 F9(a). Declared REFUTABLE + expectation: both variants redo <= 1 per node (bound 2): E purges + pending only (completed C/GC stand); S1's re-run re-derives the + same naming and G-RULE-2 suppression keeps completions. + + G6b (same chassis + between-attempt mutation of S1's scope): + re-derivation CHANGED — the C/GC tail's demand shrinks; recorded + counts are arbitration data, no declared winner (round-1 F9(b)). + + G6c (cell 28 fan-in, crash sync 2): C demanded by S1 AND S2; a + crash killing one parent mid-round must not purge (E, ∀-predicate + on the survivor's live edge) or false-refuse (S, live edge) C. + Expected bound 2; the compression divergence lives in G9. */ + +machine TestG6aE { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_E; + c.interrupt = 2; + c.execBound = 2; + new MGEnv(c); + } + } +} + +machine TestG6aS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_S; + c.interrupt = 2; + c.execBound = 2; + new MGEnv(c); + } + } +} + +machine TestG6aEProbe { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_E; + c.interrupt = 2; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6aSProbe { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_S; + c.interrupt = 2; + c.execBound = 1; + new MGEnv(c); + } + } +} + +/* GS-CO-005(c) v1 CONTROLS: the metric's zero-crash floor. No + interrupt, bound 1 — every node executes exactly once per sync + under BOTH variants; a red is a variant-overhead find (Axis-3 + data), not a kill. */ +machine TestG6aECtl { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_E; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6aSCtl { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_S; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6cECtl { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_E; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6cSCtl { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_S; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6bE { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.execBound = 2; + new MGEnv(c); + } + } +} + +machine TestG6bEProbe { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6bSProbe { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6bS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 26; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.execBound = 2; + new MGEnv(c); + } + } +} + +machine TestG6cE { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_E; + c.interrupt = 2; + c.execBound = 2; + new MGEnv(c); + } + } +} + +machine TestG6cS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_S; + c.interrupt = 2; + c.execBound = 2; + new MGEnv(c); + } + } +} + +machine TestG6cEProbe { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_E; + c.interrupt = 2; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG6cSProbe { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_S; + c.interrupt = 2; + c.execBound = 1; + new MGEnv(c); + } + } +} + +// Expected GREEN (bound 2 holds on every schedule): +test tcG6aE_All [main=TestG6aE]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND in (union Graph, { TestG6aE }); +test tcG6aS_All [main=TestG6aS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND, GPASS in (union Graph, { TestG6aS }); +test tcG6bE_All [main=TestG6bE]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND in (union Graph, { TestG6bE }); +test tcG6bS_All [main=TestG6bS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND, GPASS in (union Graph, { TestG6bS }); +test tcG6cE_All [main=TestG6cE]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND in (union Graph, { TestG6cE }); +test tcG6cS_All [main=TestG6cS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND, GPASS in (union Graph, { TestG6cS }); + +// Expected GREEN (GS-CO-005(c) v1 controls: zero-crash floor at bound 1): +test tcG6aE_Ctl [main=TestG6aECtl]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND in (union Graph, { TestG6aECtl }); +test tcG6aS_Ctl [main=TestG6aSCtl]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND, GPASS in (union Graph, { TestG6aSCtl }); +test tcG6cE_Ctl [main=TestG6cECtl]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND in (union Graph, { TestG6cECtl }); +test tcG6cS_Ctl [main=TestG6cSCtl]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND, GPASS in (union Graph, { TestG6cSCtl }); + +// Expected RED (bound-1 probes: the redo exists): +test tcG6aE_Redo [main=TestG6aEProbe]: assert GEXECBOUND in (union Graph, { TestG6aEProbe }); +test tcG6aS_Redo [main=TestG6aSProbe]: assert GEXECBOUND in (union Graph, { TestG6aSProbe }); +test tcG6bE_Redo [main=TestG6bEProbe]: assert GEXECBOUND in (union Graph, { TestG6bEProbe }); +test tcG6bS_Redo [main=TestG6bSProbe]: assert GEXECBOUND in (union Graph, { TestG6bSProbe }); +test tcG6cE_Redo [main=TestG6cEProbe]: assert GEXECBOUND in (union Graph, { TestG6cEProbe }); +test tcG6cS_Redo [main=TestG6cSProbe]: assert GEXECBOUND in (union Graph, { TestG6cSProbe }); diff --git a/formal/graph/PTst/ScenarioG7.p b/formal/graph/PTst/ScenarioG7.p new file mode 100644 index 000000000..86de0b3e7 --- /dev/null +++ b/formal/graph/PTst/ScenarioG7.p @@ -0,0 +1,50 @@ +/* G7 — progress under churn (walker P4 analog; round-1 F11 pins). + Cell 27 = cell-11 topology; node 1 (C) fails LOUD at execution + start, deterministically, in sync 2 — with a GENERATION-BLIND + fingerprint (a fingerprint hashing the generation never matches + across bumped resumes and the stuck detector goes blind; that was + F11's finding). + + - tcG7_Ladder: the abandon ladder gives up after 2 identical + fingerprints — GREEN (the sync abandons, announce-visible; the + walker's P4 tranche machinery carries over rather than + dissolving). + - tcG7_Stuck: ladderOff — the retry loop re-fails; the third + identical fingerprint is P4-STUCK RED (attempt budget 3, + SPEC 8). */ + +machine TestG7Ladder { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 27; + c.lineage = LIN_E; + c.failNode = 1; + c.failSync = 2; + c.ladder = true; + new MGEnv(c); + } + } +} + +machine TestG7Stuck { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 27; + c.lineage = LIN_E; + c.failNode = 1; + c.failSync = 2; + c.ladder = false; + new MGEnv(c); + } + } +} + +// Expected GREEN: +test tcG7_Ladder [main=TestG7Ladder]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP4STUCK in (union Graph, { TestG7Ladder }); + +// Expected RED: +test tcG7_Stuck [main=TestG7Stuck]: assert GP4STUCK in (union Graph, { TestG7Stuck }); diff --git a/formal/graph/PTst/ScenarioG8.p b/formal/graph/PTst/ScenarioG8.p new file mode 100644 index 000000000..70c6372b5 --- /dev/null +++ b/formal/graph/PTst/ScenarioG8.p @@ -0,0 +1,128 @@ +/* G8 — supersession family (round-1 F6's dedicated cells). + + G8a (record REPLACES over dead debris): NOT a dedicated cell — the + honest G1 crash cells explore every mid-record-round crash + position and the REPLACES clear wipes the debris on re-run; + registered as G1 sweep coverage (CALIBRATION.md). + + G8b (OVERLAY-intent dead base): honest leg — the DIFF unit's + atomic clear + prev-copy re-derives the base; GREEN. The + `overlayComposeDead` mutant is CONTENT-INVISIBLE in this envelope + (2 row ids + truthful TOTAL diffs: every diff from the debris's + base overwrites or removes every debris id) but NOT + mechanism-invisible (calibration find G8B-CAL-1): on the crash + re-run the skipped clear leaves the dead attempt's copy round + LIVE under the composed diff, and P1's one-live-replacement-copy + legality reds it. tcG8bMut_P1 is the kill [P1-LEGALITY]; + tcG8bMut_Ctl keeps the content-level oracles GREEN as the + registered content-invisibility evidence (adequacy §10.1). + + G8c (same-key distinct-derivation race, cell 29): P names two + DISTINCT derivations sharing output key 1 (keyOf); suppression is + correctly silent (different hashes); the store poisons the key on + the second derivation's first commit, VOIDS its marker (R2-M8), + refuses adoption store-side (R3-M2), and the poison announce + excludes the key from SealExpect; P1's legality exemption covers + the double commit. GP5 is NOT asserted here: its key = hash - 1 + identity convention is exactly what this cell breaks. + + G8d (marker flap-back probe, R2-F4): cell 11 + flapBack + two + crashes + between-attempt mutation (raw e1 -> e2 -> e3 with + content(e3) = content(e1)). Attempt 1 commits C's REPLAY unit + (marker v=1); attempt 2 re-derives FETCH-FRESH via record REPLACES + (the clear DELETES the marker); attempt 3 finds NO marker, + consults, v=1 MATCHes content(e3) truthfully, REPLAY verdict + (R3-M1) — GREEN. Mutant `markerCleanupOff`: the stale marker + survives the REPLACES; attempt 3 premise-matches it and adopts + content the marker no longer describes — P-MARK RED. */ + +machine TestG8b { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 11; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenSyncs = true; + c.diffPolicy = true; + new MGEnv(c); + } + } +} + +machine TestG8bMut { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 11; + c.lineage = LIN_E; + c.interrupt = 2; + c.mutateBetweenSyncs = true; + c.diffPolicy = true; + t = defaultGToggles(); + t.overlayComposeDead = true; + c.toggles = t; + new MGEnv(c); + } + } +} + +machine TestG8c { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 29; + c.lineage = LIN_E; + new MGEnv(c); + } + } +} + +machine TestG8d { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 11; + c.lineage = LIN_E; + c.interrupt = 3; + c.mutateBetweenAttempts = true; + c.flapBack = true; + new MGEnv(c); + } + } +} + +machine TestG8dMut { + start state I { + entry { + var c: tGCfg; + var t: tGToggles; + c = defaultGCfg(); + c.cell = 11; + c.lineage = LIN_E; + c.interrupt = 3; + c.mutateBetweenAttempts = true; + c.flapBack = true; + t = defaultGToggles(); + t.markerCleanup = false; + c.toggles = t; + new MGEnv(c); + } + } +} + +// Expected GREEN: +test tcG8b_All [main=TestG8b]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5 in (union Graph, { TestG8b }); +test tcG8bMut_Ctl [main=TestG8bMut]: assert GP2, GP3prime, SealExpectG, GP5 in (union Graph, { TestG8bMut }); +test tcG8c_All [main=TestG8c]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG in (union Graph, { TestG8c }); +test tcG8d_All [main=TestG8d]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5 in (union Graph, { TestG8d }); + +// Expected RED: +test tcG8bMut_P1 [main=TestG8bMut]: assert GP1 in (union Graph, { TestG8bMut }); +test tcG8c_Poison [main=TestG8c]: assert POISONPROBE in (union Graph, { TestG8c }); +test tcG8dMut_PMARK [main=TestG8dMut]: assert PMARK in (union Graph, { TestG8dMut }); diff --git a/formal/graph/PTst/ScenarioG9.p b/formal/graph/PTst/ScenarioG9.p new file mode 100644 index 000000000..e3a90b339 --- /dev/null +++ b/formal/graph/PTst/ScenarioG9.p @@ -0,0 +1,114 @@ +/* G9 — compression admissibility (round-1 F10). Re-runs the S legs + under `stampCompression`: the pre-seal pass compares FLOOR-BUCKETED + stamps (buckets of 2) — lossy but STALE-ERRING (never false-live: + safety preserved by construction; the recorded cost is extra + redos, because an odd-generation completion always looks stale + until the forced re-run lands on the bumped even generation). + + ADMISSIBILITY CLAIM (refutable): every safety verdict is identical + to the uncompressed legs; only the redo counts grow. Any safety + change here REFUTES the claim and halts the S recommendation. + + Growth is measured on the NO-CRASH fan-in chassis (cell 28), + where the counts are deterministic (G9-CAL-1: a crash script + masks the growth — the resume redo and the heal-wave redo both + peak at 2 per node, so the per-node bound cannot move): + tcG9cBase_All (uncompressed) is GREEN at bound 1 — every node + executes once; tcG9c_All (compressed) needs bound 2 — the first + pass scan heals every odd first-admission generation with one + forced redo; tcG9c_Redo exhibits the growth at bound 1. */ + +machine TestG9s { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.stampCompression = true; + new MGEnv(c); + } + } +} + +machine TestG9awS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 21; + c.lineage = LIN_S; + c.interrupt = 2; + c.stampCompression = true; + new MGEnv(c); + } + } +} + +machine TestG9G5aS { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 24; + c.lineage = LIN_S; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.stampCompression = true; + new MGEnv(c); + } + } +} + +machine TestG9cBase { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_S; + c.execBound = 1; + new MGEnv(c); + } + } +} + +machine TestG9c { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_S; + c.stampCompression = true; + c.execBound = 2; + new MGEnv(c); + } + } +} + +machine TestG9cProbe { + start state I { + entry { + var c: tGCfg; + c = defaultGCfg(); + c.cell = 28; + c.lineage = LIN_S; + c.stampCompression = true; + c.execBound = 1; + new MGEnv(c); + } + } +} + +// Expected GREEN (safety verdicts identical to the uncompressed legs): +test tcG9s_All [main=TestG9s]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6S, GPASS in (union Graph, { TestG9s }); +test tcG9awS_All [main=TestG9awS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP6G, GP6S, GPASS in (union Graph, { TestG9awS }); +test tcG9G5aS_All [main=TestG9G5aS]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GPASS in (union Graph, { TestG9G5aS }); +test tcG9cBase_All [main=TestG9cBase]: assert GEXECBOUND in (union Graph, { TestG9cBase }); +test tcG9c_All [main=TestG9c]: assert GP1, GP2, GP3prime, PGEN, PMARK, PADOPT, SealExpectG, GP5, GDEADDISPATCH, GEXECBOUND, GPASS in (union Graph, { TestG9c }); + +// Expected RED (the bucketing redo-growth exhibit): +test tcG9c_Redo [main=TestG9cProbe]: assert GEXECBOUND in (union Graph, { TestG9cProbe }); diff --git a/formal/graph/graph.pproj b/formal/graph/graph.pproj new file mode 100644 index 000000000..61825b577 --- /dev/null +++ b/formal/graph/graph.pproj @@ -0,0 +1,9 @@ + +graph + + ./PSrc/ + ./PSpec/ + ./PTst/ + +./PGenerated + diff --git a/formal/graph/tools/sweep.sh b/formal/graph/tools/sweep.sh new file mode 100755 index 000000000..c062875a4 --- /dev/null +++ b/formal/graph/tools/sweep.sh @@ -0,0 +1,120 @@ +#!/usr/bin/env bash +# Graph-model cell regression sweep (walker tools/sweep.sh parity). +# Verdicts are audited by counterexample trace-file presence, not the +# "Found N bugs" tail. +# +# Usage: tools/sweep.sh [schedules] (run from formal/graph) +set -u +S="${1:-10000}" +OUT="PCheckerOutput/sweep" +SUMMARY="$OUT/summary.txt" +mkdir -p "$OUT" +: > "$SUMMARY" + +# cell:expected[:strategy] (RED = counterexample expected, GREEN = +# none). Optional third field = extra p-check strategy flag for cells +# whose target is too deep for uniform random search (G1D-REACH). +CELLS=" +tcG1i_All:GREEN +tcG1ii_All:GREEN +tcG1iii_E:GREEN +tcG1iii_S:GREEN +tcG1b_All:GREEN +tcG1cMut_P3:GREEN +tcG1cMut_Seal:GREEN +tcG1sup_P1:RED +tcG1bMut_PGEN:RED +tcG1cMut_Adopt:RED +tcG2ea_Core:GREEN +tcG2eb_All:GREEN +tcG2s_All:GREEN +tcG2awE_All:GREEN +tcG2awS_All:GREEN +tcG2eb2c_All:GREEN +tcG2fbE_All:GREEN +tcG2fbS_All:GREEN +tcG2ea_P6G:RED +tcG2ebRetrOff_P6G:RED +tcG2sStampOff_P6G:RED +tcG2awE_Redo:RED +tcG2awS_Redo:RED +tcG2fbE_Redo:RED +tcG2ebPend_Redo:RED +tcG2awWA_E:RED:--sch-feedbackpct=20 +tcG2awWA_S:RED +tcG1dProbe_Redo:RED +tcG1d_P6G:RED:--sch-feedbackpct=20 +tcG1e_PGEN:RED +tcG5aE_All:GREEN +tcG5aS_All:GREEN +tcG5f_All:GREEN +tcG5bE_P5:RED +tcG5bS_P5:RED +tcG5c_P5:RED +tcG5e_Probe:RED +tcG5e_PurgeOff:RED +tcG5f_Drop:RED +tcG3_E:GREEN +tcG3_S:GREEN +tcG6aE_All:GREEN +tcG6aS_All:GREEN +tcG6bE_All:GREEN +tcG6bS_All:GREEN +tcG6cE_All:GREEN +tcG6cS_All:GREEN +tcG6aE_Redo:RED +tcG6aS_Redo:RED +tcG6cE_Redo:RED +tcG6cS_Redo:RED +tcG6aE_Ctl:GREEN +tcG6aS_Ctl:GREEN +tcG6cE_Ctl:GREEN +tcG6cS_Ctl:GREEN +tcG6bE_Redo:RED +tcG6bS_Redo:RED +tcG5dE_W1:RED +tcG5dS_W1:RED +tcG5dE_W2:RED +tcG5dS_W2:RED +tcG5dE_W3:GREEN +tcG5dS_W3:GREEN +tcG7_Ladder:GREEN +tcG7_Stuck:RED +tcG8b_All:GREEN +tcG8bMut_Ctl:GREEN +tcG8bMut_P1:RED +tcG8c_All:GREEN +tcG8c_Poison:RED +tcG8d_All:GREEN +tcG8dMut_PMARK:RED:--sch-feedbackpct=20 +tcG9s_All:GREEN +tcG9awS_All:GREEN +tcG9G5aS_All:GREEN +tcG9cBase_All:GREEN +tcG9c_All:GREEN +tcG9c_Redo:RED +" + +mismatches=0 +total=0 +for entry in $CELLS; do + rest="${entry#*:}" + cell="${entry%%:*}" + expected="${rest%%:*}" + strategy="" + case "$rest" in *:*) strategy="${rest#*:}";; esac + total=$((total + 1)) + rm -rf "$OUT/$cell" + # shellcheck disable=SC2086 + p check -tc "$cell" -s "$S" ${strategy/=/ } -o "$OUT/$cell" > "$OUT/$cell.log" 2>&1 + ce=$(ls "$OUT/$cell"/BugFinding/graph_[0-9]*_[0-9]*.txt 2>/dev/null | head -1) + if [ -n "$ce" ]; then observed="RED"; else observed="GREEN"; fi + if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi + detail="" + if [ "$observed" = "RED" ]; then + detail=" [$(rg -o "(P-GEN|P-MARK|P-ADOPT|P1-[A-Z-]+[A-Z]|P2-[A-Z]+|P3'-[A-Z]+|P4-STUCK|P5-UNDER|P5-OVER|P6-[GES]|SEAL-EXPECT|REDO-PROBE|PURGE-PROBE|POISON-PROBE|DEAD-DISPATCH|PASS-BUDGET|EXEC-BOUND|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" + fi + line="$cell expected=$expected observed=$observed $mark$detail" + echo "$line" | tee -a "$SUMMARY" +done +echo "SWEEP-DONE cells=$total mismatches=$mismatches" | tee -a "$SUMMARY" diff --git a/formal/occult/LAWS.md b/formal/occult/LAWS.md new file mode 100644 index 000000000..5c747e8e9 --- /dev/null +++ b/formal/occult/LAWS.md @@ -0,0 +1,86 @@ +# Equational laws — composition algebra and stamp lattice (deliverable 9) + +Status: CHECKED — every law below is mechanically verified against the +engine (defining equations in `src/sync_laws.occult`, checks in +`host/laws_test.go` and `host/compression_test.go`; run with +`go test ./...` in `host/`). L1–L6 and L8 are closed by equality +saturation over free Skolem constants; L7 is an ASSUMPTION (stdlib +`vector_clock` semilattice axioms instantiated on our merge — loaded so +every other check runs in their presence); L9a/L9b are ground-exhaustive +over generations 0..7 (the small-scope envelope, bound stated). Five +saturation negative controls and one ground false-live control are +refused — notably the false-live control is violated at exactly the +predicted pairs (s = cur−1, cur odd): the G9-CAL-1 parity ambiguity the +P model found dynamically, rediscovered deductively. A refuted law is a +finding and goes to the P-model change-order log, not silently +reworded. + +These are the algebraic assumptions the P models consume without +re-deriving them by state exploration (brief: "Prove them in Occult; +let P consume them as assumptions"). Each law cites the spec text that +pins it. The carrier vocabulary is `formal/GLOSSARY.md`'s. + +## Composition algebra (P1 fold, MODEL_SPEC.md §7) + +Carrier: per-(sync, scope) fold values — `empty` (the fold's initial +value, round-7 F3 pin) and `rows(e)` (scope content at upstream epoch +e). Operations are COMPLETE-round contributions (torn/incomplete +rounds never enter the fold): + +- `fresh(e)` — fetch-fresh / REPLACES round +- `repl(e)` — replacement copy of the attested base e (replay verdict) +- `ovl(e_from, e_to)` — overlay round grounded on this sync's + completed replay of `e_from` +- `ovl_sg(e_to)` — self-grounding overlay (its OWN replacement copy + committed inside the round) +- `skip(e_to)` — copy-skipped duplicate (B5-legal) + +| # | Law | Statement | Source | +|---|-----|-----------|--------| +| L1 | REPLACES absorbs | `apply(fresh(e), x) = rows(e)` for every fold value x; hence any composition suffixed by `fresh(e)` equals `rows(e)` — prior history is absorbed. | MODEL_SPEC §7 P1 fold clause "fresh(e) → rows(s, e) (REPLACES in the fold even though the store accumulates)" | +| L2 | Overlay grounds and composes | `apply(ovl(e1, e2), rows(e1)) = rows(e2)`; sequentially, `apply(ovl(e2, e3), apply(ovl(e1, e2), rows(e1))) = apply(ovl(e1, e3), rows(e1))` — truthful-diff transitivity. The truthfulness premise is the pinned trust boundary (validators truthful), NOT proved here. | MODEL_SPEC §7 "overlay(e_from → e_to) requires current fold value = rows(s, e_from), yields rows(s, e_to)"; trust boundary §"Honest limits" of the brief | +| L3 | Self-grounding absorbs | `apply(ovl_sg(e), x) = rows(e)` for every x — same absorption shape as L1; the round's own copy re-grounds the fold. | MODEL_SPEC §7 "SELF-GROUNDING — folds as rows(s, e_to) regardless of prior fold value" | +| L4 | Copy-skip is identity | `apply(skip(e), rows(e)) = rows(e)`; a copy-skipped round on any OTHER fold value is a legality violation, not a law. | MODEL_SPEC §7 "COPY-SKIPPED duplicate overlay round … folds as a NO-OP when the fold value already equals rows(s, e_to)" | +| L5 | Replay-copy idempotence | `copy(e) ∘ copy(e) = copy(e)` — an at-least-once re-run of one round's replacement copy contributes ONE counted copy (attempt-1 incomplete + attempt-2 completed count as one). | MODEL_SPEC §7 round-7 F2 pin; plan B5 "worst case … re-runs an idempotent copy" | +| L6 | Round-local tombstone ordering | Within one round, a page's upserts apply before the page's deletions; under the coalesced-delta precondition (at most one add-or-tombstone per id per round) operations on DISTINCT ids commute, so the round's result is page-order independent: `t(id1) ∘ u(id2) = u(id2) ∘ t(id1)` for `id1 ≠ id2`. Same-id cross-page re-adds are the connector's ordering responsibility (outside the algebra). | annotation_source_cache.proto `SourceCacheRecord.deleted_ids` precondition; MODEL_SPEC §"page-op ordering (copy → upserts → tombstones → publish)" | + +## Stamp lattice (variant S, GRAPH_MODEL_SPEC.md) + +Carrier: causal stamps — finite maps node → generation, merged on +read. Occult's stdlib `vector_clock` already axiomatizes the merge; the +laws below instantiate it and add the baton-specific facts. + +| # | Law | Statement | Source | +|---|-----|-----------|--------| +| L7 | Merge is a join-semilattice | `merge` is commutative, associative, idempotent (stdlib `vc_merge` axioms instantiated by our stamp carrier). | model/stdlib/vector_clock.occult (sibling repo); brief §"Division of labor" | +| L8 | Dead-membership is absorbing | `hasDead(x) → hasDead(merge(x, y))` — a merge never loses a dead generation; staleness is monotone under read-propagation. This is what makes the seal's no-dead-stamps check sufficient over merged stamps. | GRAPH_MODEL_SPEC P6-S ("no sealed output carries a stamp containing a dead generation"); §4c | +| L9a | Compressed definite-stale is sound | `floor2(s) < floor2(cur) → s < cur` (monotonicity of `floor2(g) = g − g mod 2`) — the bucketed pass never declares a LIVE entry definitely-stale. | GRAPH_MODEL_SPEC G9; graph/CALIBRATION.md find G9-CAL-1 | +| L9b | Bucket-aligned liveness is provable | If `cur` is even (bucket-aligned re-mint) and `s ≤ cur`, then `floor2(s) ≥ floor2(cur) → s = cur` — on bucket boundaries the compressed comparison proves liveness exactly; with `cur` odd the case `floor2(s) = cur − 1` is ambiguous, which is WHY the pass double-bumps (G9-CAL-1's admissible rule set). Error direction: false staleness (redo) only, never false-live. | graph/CALIBRATION.md G9-CAL-1; brief §"Variant S" ("lossy stamp compression … error direction is false staleness → redone work, never wrong data") | + +## What is assumed vs proved + +Definitional equations (the fold clauses, the merge definition, +`floor2`) are the axioms; L1–L9 are DERIVED equalities/implications the +engine must close by equality saturation (or refute). The trust-model +premises (truthful validators, coalesced deltas, non-lying connectors) +remain assumptions of the whole effort and are marked as such where a +law depends on one (L2, L6). + +Proved renderings (exact forms the engine closed): + +- L1's "any composition suffixed by fresh(e)" is closed for op-list + suffixes up to length 2 (`foldops` over the round log with a + universal preceding op) — bounded, not inductive; the single-apply + absorption is closed universally over Skolem constants. +- L5 is proved as APPLY-LEVEL idempotence (`app(repl(e)) ∘ + app(repl(e)) = app(repl(e))`); the counts-as-one bookkeeping is the + P side's F2 pin, not an algebraic statement. +- L6 is proved OBSERVATIONALLY over the two-id envelope: `get(i, ·)` + agrees on both op orders for every observer i ∈ {id1, id2}; the + coalesced-delta precondition is what makes two ids sufficient. +- L7 is loaded as an assumption, never proved; all other checks run + with the ACI axioms present, so the controls confirm the assumption + set does not collapse the algebra. +- L9a/L9b are ground-exhaustive over 0..7 × 0..7; the false-live + negative control is violated at exactly {(cur−1, cur) : cur odd}, + the parity ambiguity G9-CAL-1 hit dynamically. diff --git a/formal/occult/README.md b/formal/occult/README.md new file mode 100644 index 000000000..ea8f86060 --- /dev/null +++ b/formal/occult/README.md @@ -0,0 +1,185 @@ +# Occult track — deductive verification of sync scheduling semantics + +The parallel track to the P models (brief: +`docs/tasks/sync-formal-model-brief.md`, "Division of labor with +Occult"). P explores reachability; this track proves stated laws and +checks traces deductively with the Occult engine (sibling repo, +`../occult`). The same semantics are never modeled twice — the seams +are (a) equational proofs consumed by the P models as assumptions and +(b) one trace-policy set intended to check both P counterexample +traces and real sync executions. + +## Contents + +- `LAWS.md` — deliverable 9: the equational law inventory + (composition algebra, stamp lattice) with per-law status. The P + model specs cite this document. +- `TRACE_BRIDGE.md` — deliverable 6: the canonical trace vocabulary, + the mappings from P announce traces and real sync executions onto + it, and the runtime-trace-checker evaluation. +- `src/` — pure `.occult` sources: + - `sync_laws.occult` — defining equations of the composition + algebra, row-map observations, and stamp dead-membership. + - `sync_fixtures.occult` — free Skolem constants for law checks. + - `sync_phantom.occult` — the KNOWN-BROKEN composition vs the + premise-validated one: the phantom union stated as an algebra + (stale-attested replay base + last-sync-grounded diff). + - `sync_protocol.occult` — deliverable 8: the syncer↔connector + source-cache session terms (offer→ask→answers, bounce cap 4 + structural) with per-role projections via the engine's + protocol/projection stdlib. + - `sync_trace_policies.occult` — deliverable 7: the seven + ordering/durability policies as recursive verdict functions, with + green/red fixtures. +- `host/` — the verification harness: a standalone Go module (local + `replace` onto `../occult`; NOT part of the baton-sdk public module) + that loads the sources axiomatically and drives the engine's + equality-saturation and evaluation pipelines. Test files: + `laws_test.go`, `compression_test.go`, `phantom_test.go`, + `protocol_test.go`, `trace_policies_test.go`, + `refimpl_oracle_test.go`, `real_trace_oracle_test.go` (real syncer + traces — see below), `raft_probe_test.go` (harness positive + control), `pipeline_test.go` (the shared load/bridge/saturate + sequence). +- `host/testdata/realtraces/` — JSONL trace fixtures recorded from + REAL `pkg/sync` executions by the chaos harness + (`pkg/sync/chaos_trace_oracle_test.go`); regeneration instructions + are in that file's header comment. +- `host/refimpl/` — an executable REFERENCE implementation of the + demand-graph runtime's per-scope loop (the known-good algorithm, + which has a frozen P model but no production implementation), with a + LEGACY mode reproducing the known-broken algorithm's habits. A + modeling artifact, not production code. +- `tests/` — CLI probes (`probe_axiom_fire.occult` documents why plain + CLI file loading is definitional, which is what forced the host). + +## Running + +```bash +cd formal/occult/host && go test -timeout 30m ./... +``` + +(The saturation suites exceed go test's default 10-minute timeout +when run together.) + +Requires the sibling engine checkout at `../occult` (the go.mod +`replace` points there). The pure `.occult` sources carry no Go +dependency; baton-sdk's public module does not require the engine +repo. + +## Deliverable status + +- 9 (equational proofs): DONE — 15 laws closed by equality saturation + (L1–L6, L8 over free Skolem constants), L7 loaded as the stdlib + semilattice assumption, L9a/L9b ground-exhaustive over generations + 0..7; 5 saturation negative controls + 1 ground false-live control + refused (the false-live control reproduces G9-CAL-1's parity + ambiguity deductively). See `LAWS.md`. +- 7 (trace-policy oracle set): DONE — seven policies, 140-cell + verdict matrix (20 fixtures × 7 policies): green satisfies all, + each red violates exactly its own policy. Multi-attempt traces are + in-domain (ev_resume attempt boundaries: durable facts persist, + once-per-scope resets), and so are the delta protocol's delete leg + (ev_delete is a write: grounding, quiescence, and seal-activity + obligations) and session operations (ev_swrite / ev_sread_hit / + ev_sread_miss). + Policy 6, session_ckpt_consistency, states the CO-6b-009 root cause + — post-crash session state must equal the restored checkpoint's, no + zombie reads and no amnesia — with two directional red fixtures and + a correct-rollback green; it is the trace-policy form of the walker + model's P6-C monitor. Policy 7, external_principal_grounding, + states the deleteStaleExternalPrincipals contract — the current + answer's writes commit only after reconciliation completed, and no + dead attempt's copy survives to seal (nor is a listed principal + dropped) — with two directional reds (recon-before-copy, + stale-survivor) and two greens including the completed-then-crash + carry; it is the trace-policy form of the walker model's P8 + monitor. Generation stamps stay tracked in TRACE_BRIDGE.md. +- 8 (MPST protocol contract): DONE — 7 projection derivations (syncer + = P_leader, connector = P_follower; direct, one-bounce, and maximal + four-bounce sessions; record and replay legs) + 4 polarity/shape + controls. Bounce cap is structural (no five-bounce term exists); + stuck-freedom and cap-violation checking are open engine work. +- 6 (trace bridge): DONE — see `TRACE_BRIDGE.md`. The engine's + runtime trace checker was evaluated and NOT adopted (hardcoded + vocabulary); the deliverable-7 policy set is the oracle. The "real + executions" leg is IMPLEMENTED end to end: the shipped syncer + carries a test-only commit-order recorder + (`pkg/sync/sync_trace_audit.go`), the chaos harness exports cold, + warm, crash/resume multi-attempt, tombstone-delta, record-flip, + session-zombie, and external-principal JSONL fixtures, and + `real_trace_oracle_test.go` checks them against all seven policies + (56 cells: 54 green + TWO deliberately red — the session-zombie + fixture under session_ckpt_consistency, the standing known-defect + pin on the shipped session semantics, which flips to green when + checkpoint-consistent sessions land; and the SQLite + external-principal fixture under external_principal_grounding, the + standing known-degrade pin on the non-deleting engine's + warn-and-continue resume) with planted-violation + validation of the bridge itself (dropped consult, un-regrounded + resume, stripped resume marker, ungrounded delete, stripped + external reconciliation). The instrument + falsified a documented resume mechanism AND witnessed the model's + phantom-union prediction live in the shipped syncer (the + verdict-flip path), now fixed by record-round grounding — see the + findings at the end of `TRACE_BRIDGE.md`. The refimpl leg remains + as the demand-graph instance of the same oracle. + +## Broken vs good, both ways + +Two demonstrations pair the known-broken algorithm against the +known-good one: + +- DEDUCTIVE (`phantom_test.go` + `src/sync_phantom.occult`): the + engine PROVES the broken composition manufactures the phantom union + — a row deleted upstream survives in the sealed artifact — while + every ingredient response is individually truthful, and proves the + premise-validated grounding yields exactly upstream truth from the + same stale-cache ingredients. The controls prove the broken artifact + is NOT the epoch it claims to be. +- EXECUTABLE (`refimpl_oracle_test.go` + `host/refimpl/`): the + demand-graph reference implementation runs the same scenario to seal + — content matches upstream and every attempt trace passes all five + policies, with and without a crash. In legacy mode the sealed + artifact carries the phantom row: on a clean run the ordering + policies are (correctly) blind to it — the composition class belongs + to the algebra — and on a crash/resume run the legacy + resume-without-regrounding habit is caught by the trace oracle, + firing exactly clear-before-upsert on the resumed attempt. + +## Engine findings (for upstream) + +- Plain CLI file evaluation loads `=` definitionally; axiomatic + loading needs a host (`LoadStdlib`) — no CLI flag exists for it. +- Same-line trailing `#` comments after statements fail to parse in + stdlib-loaded modules; full-line comments only. +- Parameterized protocol definitions (`f(r) = ... send(r) ...` with + `r : Protocol`) gate their rewrite on classifier membership that + free message tags don't carry; closed session terms (the raft shape) + derive fine, and projection equivalences close as CONDITIONAL + equivalences under `Domain:Protocol` membership premises (same as + the engine's own raft test on the egraph backend). +- `pipe` has no associativity axiom: session terms and expected + projections must share the same grouping. +- Ground-term evaluation cost grows steeply (roughly doubling per + list element) when reducing recursive verdict functions over long + cons-lists under axiomatically loaded rules: a 12-element trace + evaluates in seconds, a 25-element trace exceeded 18 minutes. The + real-trace renderer coalesces consecutive checkpoints to stay + tractable; an efficient ground-evaluation path is on the engine + ask list. +- Constrained axiom universals (the `unconstrained-axiom-universal` + lint's prescribed fix, raised by the engine author against our + modules) cannot be adopted for free-constructor algebras yet: + gating a rewrite universal on a userspace sort makes dispatch + require membership evidence that free terms are never given, so + member-only ground terms stop reducing. All four documented + membership forms fail to feed the gate (set extension, extension + + `Unique`, `∃ x ∈ S;` declaration, `∈`-premise with `⇒`); built-in + classifiers (`Number`) gate correctly. Same root cause as the + parameterized-projection footgun above; pinned executable in + `host/constrained_params_probe_test.go`, which fails loudly when + the engine closes the gap (the signal to constrain our modules). + Until then our universals stay deliberately unconstrained, with + head-guard discipline (module-local constructor heads on every + LHS) as the mitigation, documented per module. diff --git a/formal/occult/TRACE_BRIDGE.md b/formal/occult/TRACE_BRIDGE.md new file mode 100644 index 000000000..e9bbc45b0 --- /dev/null +++ b/formal/occult/TRACE_BRIDGE.md @@ -0,0 +1,278 @@ +# Trace bridge — P traces and real syncs onto the Occult policy oracle (deliverable 6) + +The policy oracle set (`src/sync_trace_policies.occult`, deliverable 7) +consumes a canonical event list. This note pins the canonical +vocabulary, the two mappings onto it (P counterexample traces; real +sync executions), and the evaluation of the engine's built-in runtime +trace checker. + +## Canonical vocabulary + +One trace = one sync attempt's events, in commit order. Constructors +(two-scope envelope, matching the P models' small scopes): + +| Event | Meaning | +|-------|---------| +| `ev_consult(s)` | source-cache consult for scope s (verdict arrives with it) | +| `ev_clear(s)` | partition clear for scope s | +| `ev_replay(s)` | committed replacement copy for scope s (replay-unit commit) | +| `ev_upsert(s)` | row upsert into scope s's partition | +| `ev_publish(s)` | scope s's rows published to the artifact | +| `ev_checkpoint` | durable watermark commit | +| `ev_seal` | artifact seal | + +| `ev_delete(s)` | committed tombstone application (the delta protocol's delete leg) for scope s | +| `ev_resume` | crash/resume attempt boundary inside one sync's trace | + +`ev_delete` is a WRITE with upsert's obligations: it needs grounding +(clear-before-write — a tombstone against a base this sync never +copied is the un-regrounded class, delete flavor), dirties the +quiescent-checkpoint flag, and marks the scope active for seal +obligations. Naming note: these "tombstones" are deletion entries in +the CONNECTOR RESPONSE (`DeletedIds`/`DeletedPrincipalIds` on the +replay/record annotations), applied synchronously as plain row +deletes — nothing deletion-shaped is durably stored. + +The multi-attempt extension: a trace is ONE SYNC's events, with +`ev_resume` marking attempt boundaries. Durable facts persist across +the marker — consult flags (the checkpoint-durable hit-set), clear +grounding (committed rows), scope activity and publishes — and only +once-per-scope RESETS: an interrupted action restarts from its root +token, so the across-attempt replay re-copy is B5-legal at-least-once +idempotence, while a within-attempt duplicate remains the bug. +Single-attempt traces carry no marker and mean what they always did. + +The external-principal extension (policy 7, the +`deleteStaleExternalPrincipals` contract): `ep_list` marks a phase run +listing the external source's CURRENT answer; `ep_live(p)` declares p +a member of that answer; `ep_recon` marks reconciliation COMPLETED +(stale copies deleted, or nothing stale); `ep_copy(p)` is p's +committed principal write. These live in their own keyspace — +invisible to the artifact policies (1–5) and the session policy (6), +like session events are to both. Committed copies are DURABLE across +`ev_resume` (checkpoint resume deliberately retains completed writes), +which is the debris premise: a between-attempt shrink strands a dead +attempt's copies unless reconciliation deletes them. The +warn-and-continue degrade of a non-deleting engine emits NO `ep_recon` +— the pass ran but did not reconcile — so its first copy is the +recon-before-copy violation. + +Pending extension, tracked not modeled: generation stamps (the graph +model's variant-S lineage). + +## Mapping 1: P model announce events + +The walker and graph models announce through the monitor event +vocabulary (`formal/walker/PSrc/Events.p`, `formal/graph/PSrc/Events.p`). +A P counterexample trace renders onto the canonical list by keeping +announce events in schedule order and dropping everything else: + +| P announce | Canonical | +|------------|-----------| +| `eAnnConsult` | `ev_consult(s)` | +| `eAnnClear` / the clear leg of `eReplayUnit`/`eGReplayUnit` | `ev_clear(s)` | +| `eAnnReplay` (copy commit) | `ev_replay(s)` | +| `eAnnUpsert` | `ev_upsert(s)` | +| `eAnnPublish` / `eGSessionPub` (artifact-facing) | `ev_publish(s)` | +| `eAnnCheckpoint` | `ev_checkpoint` | +| `eAnnSealed` | `ev_seal` | + +The atomic units (`eReplayUnit`, `eOverlayUnit`, `eGOverlayUnit`) +expand to their leg order — clear, copy, marker, publish — because the +policies check the leg ordering that the units guarantee by +construction; running unit-built traces through the oracle is a +consistency check of that guarantee, not new information. Crash +scenarios cut the list at the crash point: a cut trace must still +satisfy the prefix-closed policies (1–3), while the seal-anchored +policies (4–5) are vacuous without `ev_seal` — exactly the +sync-scoped-freshness stance the models take. + +## Mapping 2: real sync executions — IMPLEMENTED + +The runtime emits the same shapes from the syncer: +`ev_consult` = the source-cache lookup round-trip; +`ev_clear`/`ev_upsert` = c1z store writes; `ev_replay` = the completed +replacement copy of an attested base; `ev_publish` = the scope's rows +becoming artifact-visible; `ev_checkpoint` = the sync-state watermark +write; `ev_seal` = `.c1z` finalization. A chaos harness (kill points +between any two events) yields cut traces checked as above. The +chaos-scenario map is: each red fixture in the policy module is the +minimal chaos outcome for its policy — e.g. `trace_red_cbp` is +"killed the watermark write, sealed anyway", `trace_red_seal` is +"sealed with an active unpublished scope" (the phantom-union family's +observable footprint at the artifact boundary). + +This leg now runs against the SHIPPED syncer. `pkg/sync` carries a +test-only commit-order recorder (`sync_trace_audit.go`, +`testSyncTraceAudit` — nil-checked, one pointer test per event, the +`testQueueAudit` pattern) fired at the orchestration seams: lookup +resolution (consult), the replay unit's clear+copy legs in the store's +contractual order, scoped page-row commits (upsert, page granularity), +manifest-entry writes (publish), durable checkpoint tokens, and +EndSync (seal). The chaos test `chaos_trace_oracle_test.go` records +the reference source-cache scenario cold and warm and exports JSONL +fixtures (`host/testdata/realtraces/`); `host/real_trace_oracle_test.go` +renders them onto the canonical vocabulary and checks all seven +policies. + +Two conventions live in the RENDERER, never the recorder (the recorder +is purely observational): scope names map onto s1/s2 in first-seen +order (two-scope envelope), and a NON-resumed attempt's upsert with no +earlier explicit clear gets a structural `ev_clear` inserted — the +partition was born empty at StartNewSync. Resumed attempts get no such +insertion, which is exactly how an un-regrounded resume reds +clear-before-upsert. The bridge itself is validated by planted +violations (`TestRealTraceBridgeCatchesPlantedViolation`): dropping the +warm fixture's consult reds policy 1, and replaying its writes as a +resumed attempt with the replay downgraded to a bare upsert reds +policy 2. + +Multi-attempt traces are in-domain too. The chaos harness cuts a warm +two-page delta round with an `EffectCrash` after the replay unit and +overlay upsert committed, resumes with a new syncer, and exports the +two attempts as one fixture with a `{"kind":"resume"}` marker line +(`warm_replay_sync_interrupted.jsonl`). All seven policies are green +on it, and `TestRealTraceBridgeResumeMarkerLoadBearing` proves the marker +is load-bearing: stripping it turns the two legal across-attempt +replays into a within-attempt duplicate and reds once-per-scope. Two +rendering notes: consecutive checkpoints coalesce to one (verdict +preserving; the engine's evaluation cost grows steeply with event +count), and the structural clear is once per scope per SYNC, attempts +included, granted to the scope's first WRITE (upsert or delete). + +The delete leg is fixtured too: `warm_replay_sync_tombstone.jsonl` +records a warm delta round that replays the base, overlay-upserts one +row, tombstones a departed row, and publishes — B3's within-page +commit order (rows, then tombstones, then the validator) appears +directly in the trace, and the exporting chaos test's content oracle +proves the tombstoned row is absent from the sealed artifact. +`TestRealTraceBridgeCatchesUngroundedDelete` plants the violation: +the same real delete with its grounding stripped reds +clear-before-upsert. + +The instrument also produced a finding about the shipped resume path: +for a mid-chain cut, the resume RE-RUNS the replay copy regardless of +checkpoint cadence — checkpoints commit at batch boundaries and a page +chain runs inside one batch, so `MarkSourceCacheReplayed` from a cut +chain never reaches a checkpoint. The resume suite's prior comment +claimed the restored replayed-set skips the copy; the trace recorder +is the first instrument able to distinguish that skip from an +idempotent re-copy, and it falsified the claimed mechanism (the +corrected comments live in `chaos_source_cache_resume_test.go`; the +convergence conclusion was always right, via B5 idempotence). The +replayed-set's real skip role is within-attempt: a later replay +annotation for an already-copied scope skips. + +The instrument's second finding was a live defect, model-predicted: +the walker calibration's scenario-1 family (the phantom union, tc1c +flavor — `formal/walker/CALIBRATION.md`) was REACHABLE in the shipped +syncer via the verdict-flip path. A warm round cut after its replay +copy committed but before its validator published, upstream moving +between attempts, and the resume's consult missing meant the connector +served a fresh RECORD round — which composed with the crashed +attempt's copied debris and sealed the union under the fresh validator +(the non-self-healing direction: the next sync's consult validates the +entry clean and replays the mosaic forward). Witnessed by +`TestChaosSourceCacheRecordFlipOverReplayDebris` +(`pkg/sync/chaos_source_cache_resume_test.go`); fixed by RECORD-ROUND +GROUNDING: a record round is a replacement listing, so before its +first write to a scope this attempt, a partition holding rows that no +completed round published is cleared (`ClearSourceCacheScope` — the +replay unit's clear leg exposed standalone; `groundRecordScope` in +`source_cache_orchestration.go`). The fix is trace-visible: record +rounds now emit a REAL `ev_clear` before their first write — +"replacement rounds clear first", previously granted structurally by +the renderer, now witnessed in `cold_record_sync.jsonl` — and the flip +scenario is fixtured as `warm_replay_sync_record_flip.jsonl`, where +attempt 2's clear with no replay after it IS the grounding. Scope +note, pinned honestly: the ordering policies do NOT red the un-fixed +flip — attempt 1's real clear grounds the scope durably across resume, +so the union was ordering-legal; it is a CONTENT violation (the +walker model's `P1-CONTENT`), owned by the exporting test's content +oracle. The policies' role in the fix is the positive direction: the +grounded trace joins the green suite. + +The instrument's third finding is a STANDING known-defect pin — the +first fixture committed with a deliberately red expectation. Sessions +commit durably at op time, OUTSIDE the checkpoint mechanism +(`SessionSet` batches commit immediately in the pebble engine), so a +crash rolls the cursor back but not the session namespace: writes from +beyond the restored checkpoint survive into the re-run window, which +can then consume its own dead attempt's "future" (CO-6b-009). The +session vocabulary (`ev_swrite`, `ev_sread_hit`, `ev_sread_miss`, keys +on the one-key `k1` envelope) and policy 6 +(`session_ckpt_consistency`) state the root cause: post-crash session +state must equal the restored checkpoint's, in both directions — +ZOMBIE (a dead attempt's beyond-checkpoint write observed by the +re-run) and AMNESIA (a checkpoint-committed value silently deleted; +its producing work never re-runs — the shape of the reverted +resume-clear fix). The fixture `warm_replay_sync_session_zombie.jsonl` +is recorded from a real crash/resume execution by +`TestChaosSourceCacheSessionPersistsAcrossResume`, which acts as the +session actor (the chaos connector has no session plumbing): the +probe write and the re-run read fire through the same recorder at the +moment of their real store operations. The oracle judges it +`violation: session-zombie-read` — asserted as the EXPECTED verdict in +`realTraceExpected`. When checkpoint-consistent sessions land (the +registered future work), the recorded read becomes a miss and the +expectation flips to "ok". The same constraint is model-side in the +walker as the P6-C monitor, whose three cells red the shipped +semantics (zombie), red the rejected wholesale clear (amnesia), and +green the checkpoint-consistent fix — `formal/walker/CALIBRATION.md`, +decision 25. + +The instrument's fourth leg is the external-principal phase +(`SyncExternalResources` — an outside source's principals copied into +the sync store beside connector rows). The syncer records `ep_list` +after the source's answer is listed, `ep_live` per member, `ep_recon` +when `deleteStaleExternalPrincipals` COMPLETES (deletes applied or +none needed — the warn-and-continue degrade branch of a non-deleting +engine records nothing), and `ep_copy` per committed principal write. +Two fixtures are exported by the existing external-principal chaos +tests: `external_resume_current_answer.jsonl` (five attempts, +capable engine, shrink mid-sync — green on all seven policies: every +resume re-lists and reconciles before copying) and +`external_resume_sqlite_degrade.jsonl` — a STANDING KNOWN-DEGRADE PIN, +expected `violation: ext-recon-before-copy`: SQLite cannot delete, the +resume warns and copies the current answer over the dead attempt's +unreconciled debris. That is the ACCEPTED degradation (one-artifact +staleness, self-healing at the next cold sync, no replay channel to +launder it further), documented mechanically as an expected red +exactly like the session pin. The renderer maps distinct principal +ids onto the two-principal envelope (p1/p2) in first-seen order and +projects further principals out — sound for the kept ones, since the +policy tracks principals independently and the recon gate is +principal-agnostic. Bridge validation for the other direction: +`TestRealTraceBridgeCatchesStaleExternalSurvivor` strips the final +attempt's reconciliation and copies from the capable-engine fixture's +REAL events and the oracle reds `ext-stale-survivor`. The same +contract is model-side in the walker as the P8 monitor (scenario 8, +`formal/walker/CALIBRATION.md`): two calibrated reds — the +non-deleting engine's stale survivor, the stale-list recency mutant — +and three greens including the completed-then-crash carry +(sync-scoped freshness). + +This leg has an executable instance: `host/refimpl/` (the demand-graph +reference implementation) emits canonical traces from real executions +of the phantom-union scenario, rendered by `RenderOccult` and checked +through the oracle in `host/refimpl_oracle_test.go`. The run also +documents the oracle's DIVISION OF LABOR empirically: the legacy +composition bug (misgrounded diff) seals a phantom artifact with a +policy-clean trace — ordering policies cannot see it, the algebra owns +it (`phantom_test.go`) — while the legacy resume-without-regrounding +habit is an ordering bug and fires clear-before-upsert on the resumed +attempt. + +## Engine runtime trace checker: evaluated, not adopted + +The engine ships a runtime trace checker +(`../occult/runtime_trace_checker.go`) with policies over a HARDCODED +vocabulary (`consume/emit/commit/checkpoint/ack` — +`runtime_trace_policies.go`). Two of its obligations rhyme with ours +(checkpoint-before-progress ~ its commit/checkpoint ordering), but the +vocabulary cannot express scopes, consults, or seals without a mapping +layer that would erase exactly the distinctions our policies check. +Decision: the oracle is the pure-Occult policy set of deliverable 7, +run through the engine host (`host/trace_policies_test.go`); the +runtime checker stays unused for this track. If the engine grows +user-defined trace vocabularies, revisit. diff --git a/formal/occult/host/compression_test.go b/formal/occult/host/compression_test.go new file mode 100644 index 000000000..14d851b1f --- /dev/null +++ b/formal/occult/host/compression_test.go @@ -0,0 +1,120 @@ +// L9 — stamp-compression admissibility (formal/occult/LAWS.md; graph +// model find G9-CAL-1). These are arithmetic facts about the floor-2 +// bucketing, checked GROUND-EXHAUSTIVELY over generations 0..7 — the +// same small-scope envelope the P models use (all known behavior fits +// it; the bound is part of the claim). Each instance is evaluated by +// the engine (native arithmetic + classify), not by Go: Go only +// enumerates the finite domain and reads the engine's verdict string. +// +// The negative control is the FALSE-LIVE claim "floor2(s) >= floor2(cur) +// implies s >= cur" — the parity ambiguity that G9-CAL-1 found +// dynamically (P PASS-BUDGET livelock). The engine must exhibit at +// least one violating pair, and exactly the predicted ones: s = cur-1 +// with cur odd. +package host_test + +import ( + "context" + "fmt" + "testing" + + occult "github.com/conductorone/occult" + "github.com/conductorone/occult/state" +) + +const genBound = 8 // generations 0..7: covers first-admission (odd) and bucket-aligned (even) mints + +// evalVerdict evaluates one engine expression that must reduce to the +// string "ok" or "violated". CLI-parity interpreter: the arithmetic and +// boolean stdlibs must be loaded for %, <, ==, classify to reduce. +func evalVerdict(t *testing.T, source string) string { + t.Helper() + interp, pm, err := occult.NewCLIInterpreter("egraph", false, "", "") + if err != nil { + t.Fatalf("NewCLIInterpreter: %v", err) + } + res, err := interp.Eval(context.Background(), "compression-check", source, pm) + if err != nil { + t.Fatalf("Eval %q: %v", source, err) + } + if res == nil || res.Loc == nil { + t.Fatalf("Eval %q: no result location", source) + } + st, ok := interp.State.Resolve(*res.Loc) + if !ok || st.Literal == nil || st.Literal.Kind != state.LitString { + t.Fatalf("Eval %q: result is not a string literal", source) + } + return st.Literal.Str +} + +// implSource renders: premise(s, cur) -> conclusion(s, cur), engine-side, +// as nested classify with string verdicts. +func implSource(premise, conclusion string, s, cur int) string { + p := fmt.Sprintf(premise, s, cur) + c := fmt.Sprintf(conclusion, s, cur) + return fmt.Sprintf( + `classify (%s) { {true,} : classify (%s) { {true,} : "ok", Bool : "violated" }, Bool : "ok" }`, + p, c) +} + +const floor2s = `(%[1]d - %[1]d %% 2)` +const floor2c = `(%[2]d - %[2]d %% 2)` + +func TestL9aDefiniteStaleSound(t *testing.T) { + // floor2(s) < floor2(cur) -> s < cur + for s := 0; s < genBound; s++ { + for cur := 0; cur < genBound; cur++ { + src := implSource(floor2s+` < `+floor2c, `%[1]d < %[2]d`, s, cur) + if v := evalVerdict(t, src); v != "ok" { + t.Errorf("L9a violated at s=%d cur=%d", s, cur) + } + } + } +} + +func TestL9bBucketAlignedLivenessProvable(t *testing.T) { + // cur even AND s <= cur AND floor2(s) >= floor2(cur) -> s = cur + for s := 0; s < genBound; s++ { + for cur := 0; cur < genBound; cur += 2 { + src := implSource( + `%[1]d <= %[2]d`, + `classify (`+floor2s+` >= `+floor2c+`) { {true,} : "inner", Bool : "vac" } == "vac"`, + s, cur) + _ = src // premise chain is easier read as two explicit classifies below + full := fmt.Sprintf( + `classify (%[1]d <= %[2]d) { {true,} : classify ((%[1]d - %[1]d %% 2) >= (%[2]d - %[2]d %% 2)) { {true,} : classify (%[1]d == %[2]d) { {true,} : "ok", Bool : "violated" }, Bool : "ok" }, Bool : "ok" }`, + s, cur) + if v := evalVerdict(t, full); v != "ok" { + t.Errorf("L9b violated at s=%d cur=%d (cur even)", s, cur) + } + } + } +} + +func TestL9NegativeControlFalseLive(t *testing.T) { + // WRONG law: floor2(s) >= floor2(cur) -> s >= cur. Must be violated, + // and exactly at the G9-CAL-1 ambiguity: s = cur-1 with cur odd. + violations := map[[2]int]bool{} + for s := 0; s < genBound; s++ { + for cur := 0; cur < genBound; cur++ { + src := implSource(floor2s+` >= `+floor2c, `%[1]d >= %[2]d`, s, cur) + if v := evalVerdict(t, src); v == "violated" { + violations[[2]int{s, cur}] = true + } + } + } + if len(violations) == 0 { + t.Fatalf("false-live control: no violating pair found — the ground check cannot refute a wrong law") + } + for pair := range violations { + s, cur := pair[0], pair[1] + if !(cur%2 == 1 && s == cur-1) { + t.Errorf("false-live control: unexpected violation shape at s=%d cur=%d (predicted only s=cur-1, cur odd)", s, cur) + } + } + for cur := 1; cur < genBound; cur += 2 { + if !violations[[2]int{cur - 1, cur}] { + t.Errorf("false-live control: predicted ambiguity pair s=%d cur=%d not exhibited", cur-1, cur) + } + } +} diff --git a/formal/occult/host/constrained_params_probe_test.go b/formal/occult/host/constrained_params_probe_test.go new file mode 100644 index 000000000..9ab77c545 --- /dev/null +++ b/formal/occult/host/constrained_params_probe_test.go @@ -0,0 +1,212 @@ +// Semantics pin: constrained axiom universals under axiomatic loading. +// +// Context: the engine author's feedback on our modules — "your +// parameters in the examples are largely unconstrained ... Something +// like p(x: Number) instead limits the matching of the callable" (lint +// kind unconstrained-axiom-universal). The hazard is real: an +// unconstrained universal matches e-classes of any shape, including +// cross-model classes merged by module bridges (the engine's +// COMMON_MISTAKES.md §7 names the arithmetic-versus-Peano regression +// this lint was added for). +// +// This probe pins why we have NOT adopted the fix for our free- +// constructor algebras (sync_trace_policies, sync_laws, sync_phantom): +// under LoadStdlib/axiomatic loading, a userspace-sort constraint on an +// axiom universal gates dispatch on classifier membership that free +// constructor terms cannot currently be given. Every documented +// membership form was tried — set extension (Scope = {s1, s2,}), set +// extension plus distinctness (Scope ∈ std.types.Unique), declaration- +// with-membership (∃ s1 ∈ Scope;), and an explicit rewrite premise +// (s ∈ Scope ⇒ rule) — and in all four the member-only green fixture +// stops reducing: membership stays undecided at dispatch, the rule is +// ineligible, the verdict is a stuck term. Built-in classifiers DO +// work (the Number probe below), so the gap is specifically userspace +// free-term membership evidence. This is the same root cause that +// blocked parameterized MPST projection (sync_protocol.occult's +// closed-term rewrite); the engine's own stdlib shows the unresolved +// state — model/stdlib/vector_clock.occult constrains its universals +// to a VectorClock sort that nothing anywhere gives members, which is +// why sync_laws.occult copies the vc_merge ACI axioms instead of +// requiring the module. +// +// The pins below assert TODAY'S behavior. When the engine lands +// membership evidence for free-term classifiers (see the "constrained +// universals" ask in docs/tasks/occult-engine-changes-brief.md), +// TestConstrainedParamsUserspaceMembershipNotConsumed fails — that is +// the signal to constrain the real modules' scope/flag universals and +// delete the pin. +package host_test + +import ( + "context" + "fmt" + "testing" + + occult "github.com/conductorone/occult" + "github.com/conductorone/occult/state" +) + +// probeConstrainedSrc gates the mini-policy's scope and flag universals +// on userspace sorts, with membership stated in the declaration form +// (∃ member ∈ Sort;). Trace tails (t, r) stay unconstrained — traces +// are inductively generated, not enumerable. +const probeConstrainedSrc = `# lint:disable mixed-source-semantics +# lint:disable unguarded-recursion +# lint:disable unconstrained-axiom-universal +syntax("standard"); + +∃ ev_a; +∃ ev_b; +∃ s_rogue; +∃ tnil; +∃ tcons; + +∃ Scope; +∃ s1 ∈ Scope; +∃ s2 ∈ Scope; +∃ Flag; +∃ tt ∈ Flag; +∃ ff ∈ Flag; + +s : Scope; +f : Flag; + +∃ probe; +∃ probe_go; +probe(t) = probe_go(t, ff); +probe_go(tnil, f) = "ok"; +probe_go(tcons(ev_a(s), r), f) = probe_go(r, tt); +probe_go(tcons(ev_b(s), r), tt) = probe_go(r, tt); +probe_go(tcons(ev_b(s), r), ff) = "violation: b-before-a"; + +∃ probe_green; +probe_green = tcons(ev_a(s1), tcons(ev_b(s2), tnil)); +∃ probe_rogue; +probe_rogue = tcons(ev_a(s_rogue), tnil); +` + +// probePremiseSrc states the gate as an explicit rewrite premise +// (s ∈ Scope ⇒ rule) — the docs' other prescribed form. Note the +// implication arrow must be ⇒ (U+21D2); ASCII => is rejected at axiom +// load with "rewrite '=>' requires rewrite LHS". +const probePremiseSrc = `# lint:disable mixed-source-semantics +# lint:disable unguarded-recursion +# lint:disable unconstrained-axiom-universal +syntax("standard"); + +∃ ev_a; +∃ ev_b; +∃ tnil; +∃ tcons; +∃ tt; +∃ ff; + +∃ Scope; +∃ s1 ∈ Scope; +∃ s2 ∈ Scope; + +∃ probe; +∃ probe_go; +probe(t) = probe_go(t, ff); +probe_go(tnil, f) = "ok"; +s ∈ Scope ⇒ probe_go(tcons(ev_a(s), r), f) = probe_go(r, tt); +s ∈ Scope ⇒ probe_go(tcons(ev_b(s), r), tt) = probe_go(r, tt); +s ∈ Scope ⇒ probe_go(tcons(ev_b(s), r), ff) = "violation: b-before-a"; + +∃ probe_green; +probe_green = tcons(ev_a(s1), tcons(ev_b(s2), tnil)); +` + +// probeBuiltinSrc constrains the scope universal to the BUILT-IN Number +// classifier with numeric scope payloads: the control proving the +// dispatch gate itself works when membership is decidable. +const probeBuiltinSrc = `# lint:disable mixed-source-semantics +# lint:disable unguarded-recursion +# lint:disable unconstrained-axiom-universal +syntax("standard"); + +∃ ev_a; +∃ ev_b; +∃ tnil; +∃ tcons; +∃ tt; +∃ ff; + +s : Number; + +∃ probe; +∃ probe_go; +probe(t) = probe_go(t, ff); +probe_go(tnil, f) = "ok"; +probe_go(tcons(ev_a(s), r), f) = probe_go(r, tt); +probe_go(tcons(ev_b(s), r), tt) = probe_go(r, tt); +probe_go(tcons(ev_b(s), r), ff) = "violation: b-before-a"; + +∃ probe_green; +probe_green = tcons(ev_a(1), tcons(ev_b(2), tnil)); +` + +// probeEval loads module src as name and evaluates M.probe(term), +// returning the verdict string and whether it reduced to one. +func probeEval(t *testing.T, name, src, term string) (string, bool) { + t.Helper() + interp, pm, err := occult.NewCLIInterpreter("egraph", false, "", "") + if err != nil { + t.Fatalf("NewCLIInterpreter: %v", err) + } + if _, err := interp.LoadStdlib(name, src, pm); err != nil { + t.Fatalf("LoadStdlib %s: %v", name, err) + } + source := fmt.Sprintf(`M = require(%q); M.probe(%s)`, name, term) + res, err := interp.Eval(context.Background(), "probe", source, pm) + if err != nil { + t.Fatalf("Eval %q: %v", source, err) + } + if res == nil || res.Loc == nil { + return "", false + } + st, ok := interp.State.Resolve(*res.Loc) + if !ok || st.Literal == nil || st.Literal.Kind != state.LitString { + return "", false + } + return st.Literal.Str, true +} + +// TestConstrainedParamsBuiltinClassifierWorks is the positive control: +// with a built-in classifier (Number) the constrained rule fires and +// the verdict reduces. The gate mechanism itself is sound. +func TestConstrainedParamsBuiltinClassifierWorks(t *testing.T) { + if v, ok := probeEval(t, "probe_builtin", probeBuiltinSrc, "M.probe_green"); !ok || v != "ok" { + t.Fatalf("green fixture under built-in Number gating: got (%q, reduced=%v), want (\"ok\", true)", v, ok) + } +} + +// TestConstrainedParamsGateRefusesNonMembers pins that the gate is +// enforced at dispatch, not advisory lint metadata: a trace carrying a +// declared-but-non-member scope does not reduce to a verdict. +func TestConstrainedParamsGateRefusesNonMembers(t *testing.T) { + if v, ok := probeEval(t, "probe_constrained", probeConstrainedSrc, "M.probe_rogue"); ok { + t.Fatalf("non-member scope reduced to %q: constraints are not gating dispatch", v) + } +} + +// TestConstrainedParamsUserspaceMembershipNotConsumed pins the gap: a +// MEMBER-only trace under userspace-sort gating does not reduce either +// — declared membership (∃ s1 ∈ Scope;) and explicit ∈-premises are +// both invisible to axiom-side dispatch, so the gate treats members +// like non-members and the rule never fires. +// +// WHEN THIS TEST FAILS (a verdict reduces): the engine has learned to +// consume userspace membership evidence. Constrain the scope/flag +// universals in sync_trace_policies.occult and sync_phantom.occult per +// the plan in the engine-changes brief, then delete this pin. +func TestConstrainedParamsUserspaceMembershipNotConsumed(t *testing.T) { + if v, ok := probeEval(t, "probe_constrained", probeConstrainedSrc, "M.probe_green"); ok { + t.Fatalf("member-only trace reduced to %q under declaration-form membership: "+ + "the engine now consumes userspace membership — constrain the real modules and delete this pin", v) + } + if v, ok := probeEval(t, "probe_premise", probePremiseSrc, "M.probe_green"); ok { + t.Fatalf("member-only trace reduced to %q under ∈-premise gating: "+ + "the engine now consumes userspace membership — constrain the real modules and delete this pin", v) + } +} diff --git a/formal/occult/host/go.mod b/formal/occult/host/go.mod new file mode 100644 index 000000000..2b43f6524 --- /dev/null +++ b/formal/occult/host/go.mod @@ -0,0 +1,13 @@ +module github.com/conductorone/baton-sdk/formal/occult/host + +go 1.26.0 + +require github.com/conductorone/occult v0.0.0-00010101000000-000000000000 + +require ( + github.com/tetratelabs/wazero v1.11.0 // indirect + golang.org/x/sync v0.19.0 // indirect + golang.org/x/sys v0.41.0 // indirect +) + +replace github.com/conductorone/occult => ../../../../occult diff --git a/formal/occult/host/go.sum b/formal/occult/host/go.sum new file mode 100644 index 000000000..820d1cb2d --- /dev/null +++ b/formal/occult/host/go.sum @@ -0,0 +1,6 @@ +github.com/tetratelabs/wazero v1.11.0 h1:+gKemEuKCTevU4d7ZTzlsvgd1uaToIDtlQlmNbwqYhA= +github.com/tetratelabs/wazero v1.11.0/go.mod h1:eV28rsN8Q+xwjogd7f4/Pp4xFxO7uOGbLcD/LzB1wiU= +golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= +golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k= +golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= diff --git a/formal/occult/host/laws_test.go b/formal/occult/host/laws_test.go new file mode 100644 index 000000000..5dd019281 --- /dev/null +++ b/formal/occult/host/laws_test.go @@ -0,0 +1,125 @@ +// Deliverable 9 (docs/tasks/sync-formal-model-brief.md): the equational +// laws of formal/occult/LAWS.md checked by equality saturation against +// the defining equations in ../src/sync_laws.occult. Each check builds a +// fresh interpreter (no cross-check e-graph pollution), loads the axiom +// module into UniversalScope, loads the two query terms as separate +// modules, bridges require() access, saturates, and asks the solver for +// equivalence. Negative controls assert NON-equivalence so a saturation +// bug that merges everything cannot silently green the law set. +// +// This module is a local verification harness: it depends on the sibling +// engine checkout via a replace directive and is not part of the +// baton-sdk public module. +package host_test + +import ( + "os" + "path/filepath" + "testing" + + occult "github.com/conductorone/occult" + "github.com/conductorone/occult/ir" +) + +func readSrc(t *testing.T, name string) string { + t.Helper() + b, err := os.ReadFile(filepath.Join("..", "src", name)) + if err != nil { + t.Fatalf("read %s: %v", name, err) + } + return string(b) +} + +// findQueryNode mirrors the engine's axiom-test helper: the query is the +// last statement of a semicolon-separated module. +func findQueryNode(interp *occult.Interpreter, rootID ir.NodeID) ir.NodeID { + node, ok := interp.Graph.Node(rootID) + if !ok { + return rootID + } + if node.Kind == ir.KindList { + children := interp.Graph.SourcesOfType(rootID, ir.EdgeAst) + if len(children) > 0 { + return children[len(children)-1] + } + } + return rootID +} + +var lawModules = []localModule{ + {"sync_laws", "sync_laws.occult"}, + {"sync_fixtures", "sync_fixtures.occult"}, +} + +// areEquivalent runs the shared pipeline with the law modules loaded. +func areEquivalent(t *testing.T, lhs, rhs string) bool { + t.Helper() + return equivalent(t, nil, lawModules, lhs, rhs) +} + +// prelude prefixes every query with the module imports. +const prelude = `exists L; L = require("sync_laws"); exists F; F = require("sync_fixtures"); ` + +type lawCase struct { + name string + lhs string + rhs string +} + +// Positive laws: MUST be equivalent. Names follow formal/occult/LAWS.md. +var lawCases = []lawCase{ + // L1 — REPLACES absorbs (and the axiom-firing sanity checks for the + // absorption clauses). + {"L1_fresh_absorbs", `L.app(L.fresh(F.e1), F.x0)`, `L.rows(F.e1)`}, + {"L1_fresh_absorbs_suffix1", `L.foldops(L.opscons(L.fresh(F.e1), L.opsnil), F.x0)`, `L.rows(F.e1)`}, + {"L1_fresh_absorbs_suffix2", `L.foldops(L.opscons(F.op0, L.opscons(L.fresh(F.e1), L.opsnil)), F.x0)`, `L.rows(F.e1)`}, + // L2 — overlay grounds and composes. + {"L2_overlay_grounds", `L.app(L.ovl(F.e1, F.e2), L.rows(F.e1))`, `L.rows(F.e2)`}, + {"L2_overlay_transitive", `L.app(L.ovl(F.e2, F.e3), L.app(L.ovl(F.e1, F.e2), L.rows(F.e1)))`, `L.app(L.ovl(F.e1, F.e3), L.rows(F.e1))`}, + // L3 — self-grounding overlay absorbs. + {"L3_selfgrounding_absorbs", `L.app(L.ovlsg(F.e1), F.x0)`, `L.rows(F.e1)`}, + // L4 — copy-skip is identity on the current value. + {"L4_skip_identity", `L.app(L.skip(F.e1), L.rows(F.e1))`, `L.rows(F.e1)`}, + // L5 — replay-copy idempotence (apply-level). + {"L5_repl_idempotent", `L.app(L.repl(F.e1), L.app(L.repl(F.e1), F.x0))`, `L.app(L.repl(F.e1), F.x0)`}, + {"L5_fresh_idempotent", `L.app(L.fresh(F.e1), L.app(L.fresh(F.e1), F.x0))`, `L.app(L.fresh(F.e1), F.x0)`}, + // L6 — distinct-id commutation (observational, both observers) and + // the same-id page-order clause. + {"L6_commute_obs1", `L.get(L.id1, L.del(L.id1, L.put(L.id2, F.v0, F.m0)))`, `L.get(L.id1, L.put(L.id2, F.v0, L.del(L.id1, F.m0)))`}, + {"L6_commute_obs2", `L.get(L.id2, L.del(L.id1, L.put(L.id2, F.v0, F.m0)))`, `L.get(L.id2, L.put(L.id2, F.v0, L.del(L.id1, F.m0)))`}, + {"L6_tombstone_after_upsert", `L.get(L.id1, L.del(L.id1, L.put(L.id1, F.v0, F.m0)))`, `L.absent`}, + // L8 — dead-membership is absorbing under merge. + {"L8_dead_absorbs_left", `L.hasdead(L.merge(L.dead(F.g0), F.y0))`, `L.tt`}, + {"L8_dead_absorbs_right", `L.hasdead(L.merge(F.y0, L.dead(F.g0)))`, `L.tt`}, + {"L8_dead_absorbs_deep", `L.hasdead(L.merge(L.merge(F.x0, L.dead(F.g0)), F.y0))`, `L.tt`}, +} + +// Negative controls: MUST NOT be equivalent. A checker that cannot +// refuse these proves nothing about the positives. +var controlCases = []lawCase{ + {"N1_overlay_not_absorbing", `L.app(L.ovl(F.e1, F.e2), F.x0)`, `L.rows(F.e2)`}, + {"N2_skip_not_absorbing", `L.app(L.skip(F.e1), F.x0)`, `L.rows(F.e1)`}, + {"N3_live_not_dead", `L.hasdead(L.live(F.g0))`, `L.tt`}, + {"N4_distinct_epochs", `L.rows(F.e1)`, `L.rows(F.e2)`}, + {"N5_put_not_invisible", `L.get(L.id1, L.put(L.id1, F.v0, F.m0))`, `L.get(L.id1, F.m0)`}, +} + +func TestLaws(t *testing.T) { + for _, c := range lawCases { + t.Run(c.name, func(t *testing.T) { + if !areEquivalent(t, prelude+c.lhs, prelude+c.rhs) { + t.Errorf("law %s: expected %q equivalent to %q", c.name, c.lhs, c.rhs) + } + }) + } +} + +func TestNegativeControls(t *testing.T) { + for _, c := range controlCases { + t.Run(c.name, func(t *testing.T) { + if areEquivalent(t, prelude+c.lhs, prelude+c.rhs) { + t.Errorf("control %s: %q must NOT be equivalent to %q — the checker cannot refuse a wrong law", c.name, c.lhs, c.rhs) + } + }) + } +} diff --git a/formal/occult/host/phantom_test.go b/formal/occult/host/phantom_test.go new file mode 100644 index 000000000..2ca8984e3 --- /dev/null +++ b/formal/occult/host/phantom_test.go @@ -0,0 +1,72 @@ +// The phantom union derived deductively (../src/sync_phantom.occult): +// the engine PROVES the known-broken composition manufactures a +// phantom row (a row deleted upstream between e0 and e1 survives in +// the sealed artifact), proves every ingredient response is +// individually truthful, and proves the premise-validated composition +// (the demand-graph runtime's grounding rule) yields exactly the +// upstream truth from the same ingredients. The negative controls are +// the finding itself: the broken artifact is provably NOT the epoch it +// claims to be. +package host_test + +import "testing" + +var phantomModules = []localModule{ + {"sync_phantom", "sync_phantom.occult"}, +} + +const phantomPrelude = `exists S; S = require("sync_phantom"); ` + +func phantomEquivalent(t *testing.T, lhs, rhs string) bool { + t.Helper() + return equivalent(t, nil, phantomModules, phantomPrelude+lhs, phantomPrelude+rhs) +} + +var phantomCases = []lawCase{ + // THE BUG, derived: the broken composition retains the deleted row. + {"phantom_row_survives", `S.get(S.id1, S.result_broken)`, `S.found(S.vx)`}, + // Ground truth at the claimed epoch: the row is absent. + {"truth_row_absent", `S.get(S.id1, S.rows_e2)`, `S.absent`}, + // Every ingredient is individually truthful — diff12 on ITS base + // (e1) produces exactly rows_e2's observations. + {"diff12_truthful_id1", `S.get(S.id1, S.diff12(S.rows_e1))`, `S.get(S.id1, S.rows_e2)`}, + {"diff12_truthful_id2", `S.get(S.id2, S.diff12(S.rows_e1))`, `S.get(S.id2, S.rows_e2)`}, + // The insidious part: on the OTHER observer the broken artifact + // looks perfect — only the phantom key betrays it. + {"broken_id2_looks_fine", `S.get(S.id2, S.result_broken)`, `S.found(S.v2)`}, + // The good composition (diff grounded at the replay's attested + // base) matches upstream truth on BOTH observers from the same + // stale-cache ingredients. + {"good_matches_truth_id1", `S.get(S.id1, S.result_good)`, `S.get(S.id1, S.rows_e2)`}, + {"good_matches_truth_id2", `S.get(S.id2, S.result_good)`, `S.get(S.id2, S.rows_e2)`}, +} + +var phantomControls = []lawCase{ + // The finding: the broken artifact provably differs from the epoch + // it claims to be (observed at the phantom key). + {"broken_is_not_e2", `S.get(S.id1, S.result_broken)`, `S.get(S.id1, S.rows_e2)`}, + // And the phantom is not somehow absent. + {"phantom_not_absent", `S.get(S.id1, S.result_broken)`, `S.absent`}, + // Broken and good compositions are observably different artifacts. + {"broken_differs_from_good", `S.get(S.id1, S.result_broken)`, `S.get(S.id1, S.result_good)`}, +} + +func TestPhantomUnionDerived(t *testing.T) { + for _, c := range phantomCases { + t.Run(c.name, func(t *testing.T) { + if !phantomEquivalent(t, c.lhs, c.rhs) { + t.Errorf("phantom case %s: expected %q equivalent to %q", c.name, c.lhs, c.rhs) + } + }) + } +} + +func TestPhantomUnionControls(t *testing.T) { + for _, c := range phantomControls { + t.Run(c.name, func(t *testing.T) { + if phantomEquivalent(t, c.lhs, c.rhs) { + t.Errorf("phantom control %s: %q must NOT be equivalent to %q", c.name, c.lhs, c.rhs) + } + }) + } +} diff --git a/formal/occult/host/pipeline_test.go b/formal/occult/host/pipeline_test.go new file mode 100644 index 000000000..bd8ae9fe1 --- /dev/null +++ b/formal/occult/host/pipeline_test.go @@ -0,0 +1,136 @@ +// Shared equivalence pipeline: the engine's axiom-test sequence (load +// modules universal-scoped, load lhs/rhs query modules global-scoped, +// load axioms/equalities, bridge require and property access, saturate, +// ask the solver). Each call builds a fresh interpreter so no e-graph +// state leaks between checks. +package host_test + +import ( + "context" + "testing" + + occult "github.com/conductorone/occult" + "github.com/conductorone/occult/ir" + "github.com/conductorone/occult/modelset" + "github.com/conductorone/occult/parse" + "github.com/conductorone/occult/solve" +) + +// localModule is a .occult source from ../src loaded into UniversalScope +// under the given require() name. +type localModule struct { + name string + file string +} + +func equivalent(t *testing.T, requires []string, locals []localModule, lhs, rhs string) bool { + t.Helper() + reg, err := modelset.Registry() + if err != nil { + t.Fatalf("modelset.Registry: %v", err) + } + interp := occult.NewInterpreter(reg, solve.NewEGraphSolver()) + pm := parse.DefaultModel() + ctx := context.Background() + + for _, name := range requires { + if err := interp.RequireModule(name); err != nil { + t.Fatalf("RequireModule %s: %v", name, err) + } + } + for _, lm := range locals { + if _, err := interp.LoadStdlib(lm.name, readSrc(t, lm.file), pm); err != nil { + t.Fatalf("LoadStdlib %s: %v", lm.name, err) + } + } + + lhsRoot, err := interp.LoadModule("lhs", lhs, parse.DefaultModel()) + if err != nil { + t.Fatalf("LoadModule lhs %q: %v", lhs, err) + } + rhsRoot, err := interp.LoadModule("rhs", rhs, parse.DefaultModel()) + if err != nil { + t.Fatalf("LoadModule rhs %q: %v", rhs, err) + } + + for _, root := range []ir.NodeID{lhsRoot, rhsRoot} { + if err := interp.AssignScopes(root, interp.GlobalScope); err != nil { + t.Fatalf("AssignScopes: %v", err) + } + if err := interp.LoadQuantifications(root); err != nil { + t.Fatalf("LoadQuantifications: %v", err) + } + if err := interp.ApplyQuantifications(root); err != nil { + t.Fatalf("ApplyQuantifications: %v", err) + } + } + + moduleRoots := interp.Graph.SourcesOfType(interp.Modules, ir.EdgeAst) + for _, root := range moduleRoots { + if err := interp.LoadAxioms(ctx, root); err != nil { + t.Fatalf("LoadAxioms root %d: %v", root, err) + } + } + allRoots := append(append([]ir.NodeID{}, moduleRoots...), lhsRoot, rhsRoot) + for _, root := range allRoots { + if err := interp.LoadEqualities(ctx, root); err != nil { + t.Fatalf("LoadEqualities root %d: %v", root, err) + } + } + for _, root := range allRoots { + if err := interp.BridgeRequireCalls(ctx, root); err != nil { + t.Fatalf("BridgeRequireCalls root %d: %v", root, err) + } + } + for _, root := range allRoots { + if err := interp.BridgeBareRequiredModuleExports(ctx, root); err != nil { + t.Fatalf("BridgeBareRequiredModuleExports root %d: %v", root, err) + } + } + + lhsQuery := findQueryNode(interp, lhsRoot) + rhsQuery := findQueryNode(interp, rhsRoot) + interp.Solver.LoadExpressions(ctx, interp.Graph, []solve.Expr{ + {RootNodeID: lhsQuery}, + {RootNodeID: rhsQuery}, + }) + for _, root := range allRoots { + if err := interp.BridgeModulePropertyAccess(ctx, root); err != nil { + t.Fatalf("BridgeModulePropertyAccess root %d: %v", root, err) + } + } + for _, root := range allRoots { + if err := interp.BridgeMethodPropertyAccess(ctx, root); err != nil { + t.Fatalf("BridgeMethodPropertyAccess root %d: %v", root, err) + } + } + + if err := interp.Saturate(ctx); err != nil { + t.Fatalf("Saturate: %v", err) + } + eq, err := interp.Solver.AreEquivalent(lhsQuery, rhsQuery) + if err != nil { + t.Fatalf("AreEquivalent: %v", err) + } + if eq { + return true + } + // The engine's axiom-test fallback: typed universals (d : Protocol) + // gate rewrites, and the egraph backend discharges them as a + // conditional equivalence with the membership premises as the + // condition. Conditional counts as equivalent — for negative + // controls too, which makes the controls STRICTER. + if conditional, ok := interp.Solver.(solve.ConditionalEquivalenceAware); ok { + condEq, condition, err := conditional.AreEquivalentWithConstraint(lhsQuery, rhsQuery) + if err != nil { + t.Fatalf("AreEquivalentWithConstraint: %v", err) + } + if condEq { + if condition != nil { + t.Logf("conditional equivalence under: %s", condition) + } + return true + } + } + return false +} diff --git a/formal/occult/host/protocol_test.go b/formal/occult/host/protocol_test.go new file mode 100644 index 000000000..5b0120d2f --- /dev/null +++ b/formal/occult/host/protocol_test.go @@ -0,0 +1,89 @@ +// Deliverable 8: projection derivations for the syncer↔connector +// source-cache protocol (../src/sync_protocol.occult) — the engine's +// Raft leader/follower derivation-test pattern applied to our contract. +// SYNCER = P_leader, CONNECTOR = P_follower. Positives prove each +// role's projected IO chain; negatives pin the polarity (a projection +// that confused the roles or erased a bounce must be refused). +// +// Stuck-freedom and bounce-cap VIOLATION checking are open engine work +// (session-types TODO); the cap is structural in the protocol module +// (no five-bounce session term exists) and its Go-side mirror is +// sourcecache.MaxLookupBouncesPerRequest. +package host_test + +import "testing" + +var protocolRequires = []string{"protocol", "projection"} + +var protocolModules = []localModule{ + {"sync_protocol", "sync_protocol.occult"}, +} + +const protoPrelude = `exists P; P = require("projection"); exists S; S = require("sync_protocol"); ` + +func protoEquivalent(t *testing.T, lhs, rhs string) bool { + t.Helper() + return equivalent(t, protocolRequires, protocolModules, protoPrelude+lhs, protoPrelude+rhs) +} + +var protocolCases = []lawCase{ + // Structural expansion of the one-bounce session. + {"expand_ask1", + `S.session_ask1`, + `S.ask_first pipe S.send(S.req_answers) pipe S.recv(S.page_record)`}, + // Direct (no-ask) page service, both roles. + {"syncer_direct", + `P.P_leader(S.session_direct)`, + `P.io_send(S.req_offer) pipe P.io_recv(S.page_record)`}, + {"connector_direct", + `P.P_follower(S.session_direct)`, + `P.io_recv(S.req_offer) pipe P.io_send(S.page_record)`}, + {"connector_direct_replay", + `P.P_follower(S.session_direct_replay)`, + `P.io_recv(S.req_offer) pipe P.io_send(S.page_replay)`}, + // One ask bounce, both roles. + {"syncer_ask1", + `P.P_leader(S.session_ask1)`, + `P.io_send(S.req_offer) pipe P.io_recv(S.lookup_ask) pipe P.local(S.resolve_answers) pipe P.io_send(S.req_answers) pipe P.io_recv(S.page_record)`}, + {"connector_ask1", + `P.P_follower(S.session_ask1)`, + `P.io_recv(S.req_offer) pipe P.io_send(S.lookup_ask) pipe P.local(S.resolve_answers) pipe P.io_recv(S.req_answers) pipe P.io_send(S.page_record)`}, + // The maximal legal session (bounce cap 4), syncer side. pipe has no + // associativity axiom (composition is a raw binary tree), so the + // expected term parenthesizes each bounce to mirror the session's + // grouping exactly. + {"syncer_ask4", + `P.P_leader(S.session_ask4)`, + `(P.io_send(S.req_offer) pipe P.io_recv(S.lookup_ask) pipe P.local(S.resolve_answers)) pipe (P.io_send(S.req_answers) pipe P.io_recv(S.lookup_ask) pipe P.local(S.resolve_answers)) pipe (P.io_send(S.req_answers) pipe P.io_recv(S.lookup_ask) pipe P.local(S.resolve_answers)) pipe (P.io_send(S.req_answers) pipe P.io_recv(S.lookup_ask) pipe P.local(S.resolve_answers)) pipe P.io_send(S.req_answers) pipe P.io_recv(S.page_record)`}, +} + +var protocolControls = []lawCase{ + // Role polarity: the two projections of one session must differ. + {"roles_differ", `P.P_leader(S.session_direct)`, `P.P_follower(S.session_direct)`}, + // A bounce is not erasable. + {"bounce_not_erasable", `S.session_ask1`, `S.session_direct`}, + // Cap shape: four bounces are not one bounce. + {"cap_shape", `P.P_leader(S.session_ask4)`, `P.P_leader(S.session_ask1)`}, + // Annotation exchange: record and replay legs differ. + {"record_not_replay", `S.session_direct`, `S.session_direct_replay`}, +} + +func TestProtocolProjections(t *testing.T) { + for _, c := range protocolCases { + t.Run(c.name, func(t *testing.T) { + if !protoEquivalent(t, c.lhs, c.rhs) { + t.Errorf("projection %s: expected %q equivalent to %q", c.name, c.lhs, c.rhs) + } + }) + } +} + +func TestProtocolControls(t *testing.T) { + for _, c := range protocolControls { + t.Run(c.name, func(t *testing.T) { + if protoEquivalent(t, c.lhs, c.rhs) { + t.Errorf("control %s: %q must NOT be equivalent to %q", c.name, c.lhs, c.rhs) + } + }) + } +} diff --git a/formal/occult/host/raft_probe_test.go b/formal/occult/host/raft_probe_test.go new file mode 100644 index 000000000..7c111e836 --- /dev/null +++ b/formal/occult/host/raft_probe_test.go @@ -0,0 +1,16 @@ +// Harness probe: the engine's own raft projection derivation run +// through OUR pipeline. If this fails while the engine's in-repo axiom +// test passes, the pipeline here is missing a step; if it passes, a +// failing sync_protocol projection is a module problem, not a harness +// problem. Kept permanently as the harness's positive control. +package host_test + +import "testing" + +func TestRaftProbe(t *testing.T) { + lhs := `exists P; P = require("projection"); exists R; R = require("raft"); P.P_leader(R.election)` + rhs := `exists P; P = require("projection"); exists R; R = require("raft"); P.io_recv(R.request_vote) pipe P.local(R.tally_votes) pipe P.io_send(R.announce_leader)` + if !equivalent(t, []string{"raft"}, nil, lhs, rhs) { + t.Fatalf("raft leader projection did not derive through this pipeline — harness gap") + } +} diff --git a/formal/occult/host/real_trace_oracle_test.go b/formal/occult/host/real_trace_oracle_test.go new file mode 100644 index 000000000..247d0b687 --- /dev/null +++ b/formal/occult/host/real_trace_oracle_test.go @@ -0,0 +1,396 @@ +// Real-sync-execution leg of the trace bridge (../TRACE_BRIDGE.md, +// mapping 2): JSONL trace fixtures recorded from REAL syncer executions +// by pkg/sync's chaos harness (chaos_trace_oracle_test.go, the +// testSyncTraceAudit recorder) are rendered onto the canonical event +// vocabulary and checked against all seven deliverable-7 policies. This +// closes the loop the brief asked for: the same oracle that gates the P +// models' traces and the refimpl's traces now gates the shipped +// syncer's commit order. +// +// KNOWN-DEFECT PIN: the session-zombie fixture (recorded by +// pkg/sync's TestChaosSourceCacheSessionPersistsAcrossResume) is +// EXPECTED RED on session_ckpt_consistency — sessions commit durably +// at op time, outside the checkpoint mechanism, so a crashed attempt's +// beyond-checkpoint write survives the cursor rollback and the re-run +// reads it (CO-6b-009). The red verdict on a real execution IS the +// mechanical catch of the shipped defect. When checkpoint-consistent +// sessions land (the registered future work), the recorded trace +// becomes a read-miss and this expectation flips to "ok". +// +// KNOWN-DEGRADE PIN: the SQLite external-principal fixture (recorded +// by pkg/sync's +// TestChaosConnectorSQLiteExternalPrincipalResumeDegradesWithoutFailure) +// is EXPECTED RED on external_principal_grounding — a non-deleting +// engine's resume warns and copies the current answer WITHOUT +// reconciling the dead attempt's stale principals, so the trace's +// resumed segment carries copies with no completed ep_recon. This is +// the ACCEPTED degradation (one-artifact staleness, self-healing at +// the next cold sync, no replay channel to launder it further); the +// red verdict on a real execution documents the acceptance +// mechanically, exactly like the session pin. +// +// Rendering conventions (the recorder is purely observational; the +// conventions live here): +// - Scopes: distinct (row_kind, scope_key) pairs map onto s1/s2 in +// first-seen order — the policies' two-scope envelope. Fixtures +// with more than two scopes are rejected. +// - External principals: distinct ep_live/ep_copy scope keys map +// onto p1/p2 in first-seen order; further principals are PROJECTED +// OUT (their events dropped). Sound for the kept principals: the +// policy tracks each principal independently, and the recon gate +// is principal-agnostic (every attempt in the committed fixtures +// copies the first-seen principal, so a missing ep_recon still +// fires on a kept copy). +// - Structural clear: a trace that starts at sync birth +// (header resumed=false) writes into partitions StartNewSync +// created empty, so an upsert with no earlier explicit clear for +// its scope gets an ev_clear inserted before it — once per scope +// for the WHOLE sync trace, attempts included (the partition is +// born empty once). A trace beginning mid-sync (resumed=true) +// gets no insertion — exactly the case clear-before-upsert exists +// to catch. All committed fixtures start at sync birth. +// - Resume markers: multi-attempt fixtures carry {"kind":"resume"} +// lines between attempt segments, rendered as ev_resume. +// - Checkpoint coalescing: a run of consecutive checkpoints renders +// as ONE ev_checkpoint. Verdict-preserving by inspection of all +// five policies: four pass checkpoints through untouched and the +// fifth (checkpoint-before-progress) sets an idempotent flag, so +// back-to-back checkpoints are indistinguishable from one. Needed +// because the engine's term evaluation cost grows steeply with +// event count (a 25-event trace exceeds 18 minutes per cell; 14 +// events evaluate in tens of seconds). +package host_test + +import ( + "bufio" + "encoding/json" + "fmt" + "os" + "path/filepath" + "testing" +) + +type realTraceHeader struct { + Name string `json:"name"` + Resumed bool `json:"resumed"` +} + +type realTraceEvent struct { + Kind string `json:"kind"` + RowKind string `json:"row_kind"` + ScopeKey string `json:"scope_key"` +} + +// loadRealTrace parses one JSONL fixture: a header line then one event +// per line. +func loadRealTrace(t *testing.T, path string) (realTraceHeader, []realTraceEvent) { + t.Helper() + f, err := os.Open(path) + if err != nil { + t.Fatalf("open %s: %v", path, err) + } + defer f.Close() + scanner := bufio.NewScanner(f) + if !scanner.Scan() { + t.Fatalf("%s: empty fixture", path) + } + var header realTraceHeader + if err := json.Unmarshal(scanner.Bytes(), &header); err != nil { + t.Fatalf("%s: header: %v", path, err) + } + var events []realTraceEvent + for scanner.Scan() { + if len(scanner.Bytes()) == 0 { + continue + } + var ev realTraceEvent + if err := json.Unmarshal(scanner.Bytes(), &ev); err != nil { + t.Fatalf("%s: event: %v", path, err) + } + events = append(events, ev) + } + if err := scanner.Err(); err != nil { + t.Fatalf("%s: scan: %v", path, err) + } + if len(events) == 0 { + t.Fatalf("%s: no events", path) + } + return header, events +} + +// renderRealTrace converts a recorded event list into a canonical trace +// term over the policy module's constructors. +func renderRealTrace(t *testing.T, header realTraceHeader, events []realTraceEvent) string { + t.Helper() + scopes := map[string]string{} + scopeName := func(ev realTraceEvent) string { + key := ev.RowKind + "\x00" + ev.ScopeKey + if name, ok := scopes[key]; ok { + return name + } + name := fmt.Sprintf("s%d", len(scopes)+1) + if len(scopes) >= 2 { + t.Fatalf("fixture %s has more than two scopes (policies' two-scope envelope)", header.Name) + } + scopes[key] = name + return name + } + cleared := map[string]bool{} + sessionKey := "" + principals := map[string]string{} + principalName := func(ev realTraceEvent) string { + if name, ok := principals[ev.ScopeKey]; ok { + return name + } + if len(principals) >= 2 { + // Projection: principals beyond the envelope drop out + // (see the file comment). + return "" + } + name := fmt.Sprintf("p%d", len(principals)+1) + principals[ev.ScopeKey] = name + return name + } + var canonical []string + for _, ev := range events { + switch ev.Kind { + case "checkpoint": + if len(canonical) > 0 && canonical[len(canonical)-1] == "ev_checkpoint" { + continue + } + canonical = append(canonical, "ev_checkpoint") + case "seal": + canonical = append(canonical, "ev_seal") + case "resume": + canonical = append(canonical, "ev_resume") + case "swrite", "sread_hit", "sread_miss": + // Session events map onto the policy module's one-key + // envelope (k1), separate from the artifact scopes. + if sessionKey == "" { + sessionKey = ev.ScopeKey + } + if ev.ScopeKey != sessionKey { + t.Fatalf("fixture %s has more than one session key (policies' one-key envelope)", header.Name) + } + canonical = append(canonical, "ev_"+ev.Kind+"(M.k1)") + case "ep_list", "ep_recon": + canonical = append(canonical, ev.Kind) + case "ep_live", "ep_copy": + p := principalName(ev) + if p == "" { + continue + } + canonical = append(canonical, fmt.Sprintf("%s(M.%s)", ev.Kind, p)) + case "consult", "clear", "replay", "upsert", "delete", "publish": + s := scopeName(ev) + if ev.Kind == "clear" { + cleared[s] = true + } + if (ev.Kind == "upsert" || ev.Kind == "delete") && !cleared[s] && !header.Resumed { + // Structural clear: the partition was born empty this + // sync (see the file comment). Deletes are writes and + // need the same grounding as upserts. + canonical = append(canonical, "ev_clear(M."+s+")") + cleared[s] = true + } + canonical = append(canonical, fmt.Sprintf("ev_%s(M.%s)", ev.Kind, s)) + default: + t.Fatalf("fixture %s: unknown event kind %q", header.Name, ev.Kind) + } + } + term := "M.tnil" + for i := len(canonical) - 1; i >= 0; i-- { + term = fmt.Sprintf("M.tcons(M.%s, %s)", canonical[i], term) + } + return term +} + +// realTraceExpected overrides the default "ok" expectation for +// (fixture, policy) cells: the two standing pins (see the file +// comment) — the shipped session semantics' zombie read, and the +// non-deleting engine's unreconciled external-principal copy. Each is +// RED on a real execution's trace by design. +var realTraceExpected = map[string]map[string]string{ + "warm_replay_sync_session_zombie": { + "session_ckpt_consistency": "violation: session-zombie-read", + }, + "external_resume_sqlite_degrade": { + "external_principal_grounding": "violation: ext-recon-before-copy", + }, +} + +// TestRealSyncTracesSatisfyPolicies checks every committed real-trace +// fixture against all seven policies. +func TestRealSyncTracesSatisfyPolicies(t *testing.T) { + paths, err := filepath.Glob(filepath.Join("testdata", "realtraces", "*.jsonl")) + if err != nil { + t.Fatalf("glob: %v", err) + } + if len(paths) == 0 { + t.Fatal("no real-trace fixtures committed under testdata/realtraces") + } + for _, path := range paths { + header, events := loadRealTrace(t, path) + term := renderRealTrace(t, header, events) + for _, policy := range policies { + t.Run(header.Name+"/"+policy, func(t *testing.T) { + want := "ok" + if overrides, ok := realTraceExpected[header.Name]; ok { + if v, ok := overrides[policy]; ok { + want = v + } + } + verdict := policyVerdictTerm(t, policy, term) + if verdict != want { + t.Errorf("real trace %s under %s: want %q, got %q\nterm: %s", header.Name, policy, want, verdict, term) + } + }) + } + } +} + +// TestRealTraceBridgeCatchesPlantedViolation validates the bridge +// itself (instrument validation: the oracle must fail on a planted +// violation, or a rendering bug that greens everything would pass +// silently). It mutates the warm fixture's REAL events two ways: +// dropping the consult must red consult-before-replay, and replaying +// the same events as a RESUMED attempt with an upsert in place of the +// replay unit must red clear-before-upsert (no structural clear). +func TestRealTraceBridgeCatchesPlantedViolation(t *testing.T) { + path := filepath.Join("testdata", "realtraces", "warm_replay_sync.jsonl") + header, events := loadRealTrace(t, path) + + var noConsult []realTraceEvent + for _, ev := range events { + if ev.Kind == "consult" { + continue + } + noConsult = append(noConsult, ev) + } + term := renderRealTrace(t, header, noConsult) + if verdict := policyVerdictTerm(t, "consult_before_replay", term); verdict != "violation: consult-before-replay" { + t.Errorf("planted consult drop not caught, verdict %q", verdict) + } + + resumed := realTraceHeader{Name: "planted-resume", Resumed: true} + var upsertOnly []realTraceEvent + for _, ev := range events { + switch ev.Kind { + case "clear", "replay", "consult": + if ev.Kind == "replay" { + upsertOnly = append(upsertOnly, realTraceEvent{Kind: "upsert", RowKind: ev.RowKind, ScopeKey: ev.ScopeKey}) + } + default: + upsertOnly = append(upsertOnly, ev) + } + } + term = renderRealTrace(t, resumed, upsertOnly) + if verdict := policyVerdictTerm(t, "clear_before_upsert", term); verdict != "violation: clear-before-upsert" { + t.Errorf("planted un-regrounded resume not caught, verdict %q", verdict) + } +} + +// TestRealTraceBridgeCatchesUngroundedDelete validates the delete leg +// of the bridge: the tombstone fixture's REAL delete, replayed as a +// mid-sync trace with its grounding (clear+replay) and upsert stripped, +// must red clear-before-upsert — a tombstone against a base this trace +// never copied is the un-regrounded-resume class, delete flavor. +func TestRealTraceBridgeCatchesUngroundedDelete(t *testing.T) { + path := filepath.Join("testdata", "realtraces", "warm_replay_sync_tombstone.jsonl") + header, events := loadRealTrace(t, path) + + term := renderRealTrace(t, header, events) + if verdict := policyVerdictTerm(t, "clear_before_upsert", term); verdict != "ok" { + t.Errorf("honest tombstone trace must satisfy clear-before-upsert, got %q", verdict) + } + + hasDelete := false + var ungrounded []realTraceEvent + for _, ev := range events { + switch ev.Kind { + case "clear", "replay", "upsert": + continue + case "delete": + hasDelete = true + } + ungrounded = append(ungrounded, ev) + } + if !hasDelete { + t.Fatal("tombstone fixture carries no delete event; the delete leg is not being exercised") + } + term = renderRealTrace(t, realTraceHeader{Name: "planted-ungrounded-delete", Resumed: true}, ungrounded) + if verdict := policyVerdictTerm(t, "clear_before_upsert", term); verdict != "violation: clear-before-upsert" { + t.Errorf("planted ungrounded delete not caught, verdict %q", verdict) + } +} + +// TestRealTraceBridgeResumeMarkerLoadBearing validates the multi-attempt +// leg of the bridge: the interrupted fixture's two replays are legal +// ONLY because a resume marker separates them (once-per-scope resets at +// the boundary). Deleting the marker must turn the same events into a +// within-attempt duplicate copy and red once-per-scope — proving the +// marker, and therefore the attempt segmentation, is load-bearing. +func TestRealTraceBridgeResumeMarkerLoadBearing(t *testing.T) { + path := filepath.Join("testdata", "realtraces", "warm_replay_sync_interrupted.jsonl") + header, events := loadRealTrace(t, path) + + hasResume := false + var noMarker []realTraceEvent + for _, ev := range events { + if ev.Kind == "resume" { + hasResume = true + continue + } + noMarker = append(noMarker, ev) + } + if !hasResume { + t.Fatal("interrupted fixture carries no resume marker; the multi-attempt leg is not being exercised") + } + + term := renderRealTrace(t, header, events) + if verdict := policyVerdictTerm(t, "once_per_scope", term); verdict != "ok" { + t.Errorf("marked multi-attempt trace must satisfy once-per-scope, got %q", verdict) + } + term = renderRealTrace(t, header, noMarker) + if verdict := policyVerdictTerm(t, "once_per_scope", term); verdict != "violation: once-per-scope" { + t.Errorf("marker-stripped trace must red once-per-scope, got %q", verdict) + } +} + +// TestRealTraceBridgeCatchesStaleExternalSurvivor validates the +// external-principal leg of the bridge (instrument validation for the +// stale-survivor direction; the recon-before-copy direction is already +// witnessed by the SQLite degrade pin). The capable-engine fixture's +// REAL events, with the FINAL attempt's reconciliation and copies +// stripped, describe a history where a dead attempt's principal +// reaches the seal undeleted — the oracle must red ext-stale-survivor. +func TestRealTraceBridgeCatchesStaleExternalSurvivor(t *testing.T) { + path := filepath.Join("testdata", "realtraces", "external_resume_current_answer.jsonl") + header, events := loadRealTrace(t, path) + + term := renderRealTrace(t, header, events) + if verdict := policyVerdictTerm(t, "external_principal_grounding", term); verdict != "ok" { + t.Errorf("honest capable-engine trace must satisfy external_principal_grounding, got %q", verdict) + } + + lastResume := -1 + for i, ev := range events { + if ev.Kind == "resume" { + lastResume = i + } + } + if lastResume < 0 { + t.Fatal("capable-engine fixture carries no resume marker; the multi-attempt leg is not being exercised") + } + var mutated []realTraceEvent + for i, ev := range events { + if i > lastResume && (ev.Kind == "ep_recon" || ev.Kind == "ep_copy") { + continue + } + mutated = append(mutated, ev) + } + term = renderRealTrace(t, header, mutated) + if verdict := policyVerdictTerm(t, "external_principal_grounding", term); verdict != "violation: ext-stale-survivor" { + t.Errorf("planted stale external survivor not caught, verdict %q", verdict) + } +} diff --git a/formal/occult/host/refimpl/refimpl.go b/formal/occult/host/refimpl/refimpl.go new file mode 100644 index 000000000..dfeb34b79 --- /dev/null +++ b/formal/occult/host/refimpl/refimpl.go @@ -0,0 +1,219 @@ +// Package refimpl is an executable REFERENCE implementation of the +// demand-graph runtime's per-scope sync loop (formal/GRAPH_MODEL_SPEC.md) +// — the "known good" algorithm, which has a frozen P model but no +// production implementation yet. It exists to be tried out: it runs the +// phantom-union scenario end to end, emits canonical traces in the +// TRACE_BRIDGE.md vocabulary, and carries a LEGACY mode reproducing the +// known-broken algorithm's two failure habits: +// +// 1. overlay grounding at the last sync's epoch instead of the replay +// marker's attested base (the phantom-union composition), and +// 2. resume-without-regrounding: after a crash, a non-empty partition +// is treated as already-replayed and overlaid directly, instead of +// re-executing the node under a fresh generation. +// +// This is a modeling artifact, single-threaded and in-memory; it is +// deliberately NOT production code and lives outside baton-sdk's public +// module. The store commits writes durably as they happen (they survive +// a crash); the checkpoint is the scheduler watermark, exactly the +// walker/graph models' crash semantics. +package refimpl + +import ( + "fmt" + "sort" +) + +// Mode selects the algorithm under test. +type Mode int + +const ( + // ModeDemandGraph is the known-good algorithm: premise-validated + // grounding, generation-bump re-execution on resume. + ModeDemandGraph Mode = iota + // ModeLegacy reproduces the known-broken algorithm. + ModeLegacy +) + +// Event is one canonical trace event (TRACE_BRIDGE.md vocabulary). +type Event struct { + Kind string // consult, clear, replay, upsert, publish, checkpoint, seal + Scope string // "" for checkpoint/seal +} + +// Upstream is the truthful system of record: a row set per epoch and +// honest diffs between any two epochs. +type Upstream struct { + epochs []map[string]string +} + +func NewUpstream(epochs ...map[string]string) *Upstream { + return &Upstream{epochs: epochs} +} + +func (u *Upstream) Rows(e int) map[string]string { + out := map[string]string{} + for k, v := range u.epochs[e] { + out[k] = v + } + return out +} + +// Diff returns the truthful delta from one epoch to another: upserts +// for added/changed ids, deletes for removed ids. It never mentions an +// id that did not change — which is exactly what makes the misgrounded +// composition dangerous. +func (u *Upstream) Diff(from, to int) (upserts map[string]string, deletes []string) { + upserts = map[string]string{} + a, b := u.epochs[from], u.epochs[to] + for k, v := range b { + if av, ok := a[k]; !ok || av != v { + upserts[k] = v + } + } + for k := range a { + if _, ok := b[k]; !ok { + deletes = append(deletes, k) + } + } + sort.Strings(deletes) + return upserts, deletes +} + +// Cache is the source-cache offer for the scope: rows attested at Base. +// The consult verdict truthfully reports Base. +type Cache struct { + Base int + Rows map[string]string +} + +// Config describes one sync of one scope. +type Config struct { + Mode Mode + Upstream *Upstream + Head int // the epoch this sync must land on + Cache Cache // the connector's replay offer + LastSyncEpoch int // what the previous completed sync attested (the legacy grounding source) + // CrashAfterReplay kills attempt 1 after the replay unit commits + // and before any checkpoint, then resumes as attempt 2. + CrashAfterReplay bool +} + +// Result is the sealed artifact content plus the canonical trace of +// every attempt (crash-cut traces included). +type Result struct { + Sealed map[string]string + Attempts [][]Event +} + +const scope = "s1" + +// durable is the store state that survives a crash. +type durable struct { + partition map[string]string + hasMarker bool + markerBase int // the replay unit's attested base epoch + checkpoint bool // scope watermark: scope completed at Head +} + +// Run executes the sync to seal, crashing and resuming if configured. +func Run(cfg Config) Result { + st := &durable{partition: map[string]string{}} + var attempts [][]Event + for attempt := 1; ; attempt++ { + trace, sealed := runAttempt(cfg, st, attempt) + attempts = append(attempts, trace) + if sealed { + return Result{Sealed: st.partition, Attempts: attempts} + } + if attempt > 2 { + panic("refimpl: more than one resume in a two-attempt scenario") + } + } +} + +func runAttempt(cfg Config, st *durable, attempt int) (trace []Event, sealed bool) { + emit := func(kind, sc string) { trace = append(trace, Event{Kind: kind, Scope: sc}) } + + replayed := false + switch { + case cfg.Mode == ModeLegacy && len(st.partition) > 0 && attempt > 1: + // LEGACY resume habit: a non-empty partition is treated as + // already-replayed. No consult, no clear, no fresh generation — + // straight to the overlay on top of whatever the dead attempt + // left behind. + default: + // Demand-graph path (and legacy attempt 1): consult the source + // cache; the verdict truthfully attests the cache's base epoch. + emit("consult", scope) + // Replay unit — atomic clear + copy + marker (the eGReplayUnit + // shape: the marker commits with the copy or not at all). + st.partition = map[string]string{} + for k, v := range cfg.Cache.Rows { + st.partition[k] = v + } + st.hasMarker = true + st.markerBase = cfg.Cache.Base + emit("clear", scope) + emit("replay", scope) + replayed = true + } + + if cfg.CrashAfterReplay && attempt == 1 && replayed { + // Crash: store writes above are durable; nothing was + // checkpointed. The trace is cut here. + return trace, false + } + + // Overlay: bring the partition from the grounded base to Head. + ground := st.markerBase // premise-validated: the marker's attestation + if cfg.Mode == ModeLegacy { + ground = cfg.LastSyncEpoch // the broken habit: last sync's epoch + } + upserts, deletes := cfg.Upstream.Diff(ground, cfg.Head) + for _, k := range sortedKeys(upserts) { + st.partition[k] = upserts[k] + emit("upsert", scope) + } + for _, k := range deletes { + delete(st.partition, k) + // Tombstones have no canonical event yet (TRACE_BRIDGE.md + // pending extensions); the content oracle still sees them. + } + + emit("publish", scope) + st.checkpoint = true + emit("checkpoint", "") + emit("seal", "") + return trace, true +} + +func sortedKeys(m map[string]string) []string { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + sort.Strings(keys) + return keys +} + +// RenderOccult renders one attempt's trace as an Occult term over the +// sync_trace_policies constructors, with every constructor accessed +// through the module handle m (e.g. "M"). +func RenderOccult(m string, trace []Event) string { + term := m + ".tnil" + for i := len(trace) - 1; i >= 0; i-- { + ev := trace[i] + var atom string + switch ev.Kind { + case "checkpoint": + atom = fmt.Sprintf("%s.ev_checkpoint", m) + case "seal": + atom = fmt.Sprintf("%s.ev_seal", m) + default: + atom = fmt.Sprintf("%s.ev_%s(%s.%s)", m, ev.Kind, m, ev.Scope) + } + term = fmt.Sprintf("%s.tcons(%s, %s)", m, atom, term) + } + return term +} diff --git a/formal/occult/host/refimpl_oracle_test.go b/formal/occult/host/refimpl_oracle_test.go new file mode 100644 index 000000000..b9ea37f6b --- /dev/null +++ b/formal/occult/host/refimpl_oracle_test.go @@ -0,0 +1,123 @@ +// The demand-graph reference implementation (refimpl/) tried out +// against two oracles on the phantom-union scenario: +// +// - CONTENT oracle (Go): the sealed artifact must equal upstream at +// the head epoch. +// - TRACE oracle (engine): every attempt's canonical trace is checked +// against all five deliverable-7 policies. +// +// The matrix this asserts: +// +// demand-graph, no crash -> content true, all policies ok +// demand-graph, crash+resume -> content true, all policies ok (both attempts) +// legacy, no crash -> content FALSE (phantom row) but all +// policies ok — the ordering policies are provably blind to the +// composition bug; that class is owned by the algebra +// (phantom_test.go derives it deductively) +// legacy, crash+resume -> content FALSE and attempt 2 violates +// exactly clear-before-upsert (resume-without-regrounding is an +// ordering bug, and the oracle catches it) +package host_test + +import ( + "reflect" + "testing" + + "github.com/conductorone/baton-sdk/formal/occult/host/refimpl" +) + +// The sync_phantom.occult scenario: id1 deleted between e0 and e1, +// id2's value changes between e1 and e2, the source cache is attested +// at e0, the previous sync completed at e1, and this sync targets e2. +func phantomConfig(mode refimpl.Mode, crash bool) refimpl.Config { + up := refimpl.NewUpstream( + map[string]string{"id1": "vx", "id2": "v1"}, // e0 + map[string]string{"id2": "v1"}, // e1 + map[string]string{"id2": "v2"}, // e2 + ) + return refimpl.Config{ + Mode: mode, + Upstream: up, + Head: 2, + Cache: refimpl.Cache{Base: 0, Rows: up.Rows(0)}, + LastSyncEpoch: 1, + CrashAfterReplay: crash, + } +} + +var truthAtHead = map[string]string{"id2": "v2"} +var phantomArtifact = map[string]string{"id1": "vx", "id2": "v2"} + +// checkAttempts runs every attempt trace through all five policies and +// asserts the expected verdict: expectViolation maps attempt index +// (0-based) to the one policy that must fire; every other cell must be +// "ok". +func checkAttempts(t *testing.T, attempts [][]refimpl.Event, expectViolation map[int]string) { + t.Helper() + for i, trace := range attempts { + term := refimpl.RenderOccult("M", trace) + for _, policy := range policies { + verdict := policyVerdictTerm(t, policy, term) + if expectViolation[i] == policy { + if verdict != "violation: "+policyLabel(policy) { + t.Errorf("attempt %d: expected %s to fire, got %q", i+1, policy, verdict) + } + } else if verdict != "ok" { + t.Errorf("attempt %d: expected %s ok, got %q", i+1, policy, verdict) + } + } + } +} + +func TestRefImplDemandGraph(t *testing.T) { + res := refimpl.Run(phantomConfig(refimpl.ModeDemandGraph, false)) + if !reflect.DeepEqual(res.Sealed, truthAtHead) { + t.Errorf("sealed content %v, want upstream truth %v", res.Sealed, truthAtHead) + } + if len(res.Attempts) != 1 { + t.Fatalf("expected 1 attempt, got %d", len(res.Attempts)) + } + checkAttempts(t, res.Attempts, nil) +} + +func TestRefImplDemandGraphCrashResume(t *testing.T) { + res := refimpl.Run(phantomConfig(refimpl.ModeDemandGraph, true)) + if !reflect.DeepEqual(res.Sealed, truthAtHead) { + t.Errorf("sealed content %v, want upstream truth %v", res.Sealed, truthAtHead) + } + if len(res.Attempts) != 2 { + t.Fatalf("expected 2 attempts, got %d", len(res.Attempts)) + } + // Attempt 1 is a crash-cut prefix; attempt 2 re-executes the node + // under a fresh generation (consult, clear, replay again). Both + // must satisfy every policy. + checkAttempts(t, res.Attempts, nil) +} + +func TestRefImplLegacyPhantom(t *testing.T) { + res := refimpl.Run(phantomConfig(refimpl.ModeLegacy, false)) + if !reflect.DeepEqual(res.Sealed, phantomArtifact) { + t.Errorf("sealed content %v, want the phantom artifact %v", res.Sealed, phantomArtifact) + } + if reflect.DeepEqual(res.Sealed, truthAtHead) { + t.Errorf("legacy mode unexpectedly produced the true artifact") + } + // The ordering policies are BLIND to this one: the event order is + // identical to the honest run. The finding lives in the content + // oracle here and in the algebra deductively (phantom_test.go). + checkAttempts(t, res.Attempts, nil) +} + +func TestRefImplLegacyCrashResume(t *testing.T) { + res := refimpl.Run(phantomConfig(refimpl.ModeLegacy, true)) + if !reflect.DeepEqual(res.Sealed, phantomArtifact) { + t.Errorf("sealed content %v, want the phantom artifact %v", res.Sealed, phantomArtifact) + } + if len(res.Attempts) != 2 { + t.Fatalf("expected 2 attempts, got %d", len(res.Attempts)) + } + // Attempt 2 resumed onto the dead attempt's partition without + // re-grounding: upserts with no clear this attempt. The trace + // oracle must catch exactly clear-before-upsert. + checkAttempts(t, res.Attempts, map[int]string{1: "clear_before_upsert"}) +} diff --git a/formal/occult/host/testdata/realtraces/cold_record_sync.jsonl b/formal/occult/host/testdata/realtraces/cold_record_sync.jsonl new file mode 100644 index 000000000..b6de7067a --- /dev/null +++ b/formal/occult/host/testdata/realtraces/cold_record_sync.jsonl @@ -0,0 +1,8 @@ +{"name":"cold_record_sync","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"upsert","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"publish","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"checkpoint"} +{"kind":"seal"} diff --git a/formal/occult/host/testdata/realtraces/external_resume_current_answer.jsonl b/formal/occult/host/testdata/realtraces/external_resume_current_answer.jsonl new file mode 100644 index 000000000..069e01faa --- /dev/null +++ b/formal/occult/host/testdata/realtraces/external_resume_current_answer.jsonl @@ -0,0 +1,36 @@ +{"name":"external_resume_current_answer","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"ep_list"} +{"kind":"ep_live","scope_key":"external-group-1"} +{"kind":"ep_live","scope_key":"external-user-1"} +{"kind":"ep_live","scope_key":"external-user-2"} +{"kind":"ep_recon"} +{"kind":"ep_copy","scope_key":"external-group-1"} +{"kind":"ep_copy","scope_key":"external-user-1"} +{"kind":"ep_copy","scope_key":"external-user-2"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"ep_list"} +{"kind":"ep_live","scope_key":"external-group-1"} +{"kind":"ep_live","scope_key":"external-user-2"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"ep_list"} +{"kind":"ep_live","scope_key":"external-group-1"} +{"kind":"ep_live","scope_key":"external-user-2"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"ep_list"} +{"kind":"ep_live","scope_key":"external-group-1"} +{"kind":"ep_live","scope_key":"external-user-2"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"ep_list"} +{"kind":"ep_live","scope_key":"external-group-1"} +{"kind":"ep_live","scope_key":"external-user-2"} +{"kind":"ep_recon"} +{"kind":"ep_copy","scope_key":"external-group-1"} +{"kind":"ep_copy","scope_key":"external-user-2"} +{"kind":"checkpoint"} +{"kind":"seal"} diff --git a/formal/occult/host/testdata/realtraces/external_resume_sqlite_degrade.jsonl b/formal/occult/host/testdata/realtraces/external_resume_sqlite_degrade.jsonl new file mode 100644 index 000000000..989792a4e --- /dev/null +++ b/formal/occult/host/testdata/realtraces/external_resume_sqlite_degrade.jsonl @@ -0,0 +1,20 @@ +{"name":"external_resume_sqlite_degrade","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"ep_list"} +{"kind":"ep_live","scope_key":"external-group-1"} +{"kind":"ep_live","scope_key":"external-user-1"} +{"kind":"ep_live","scope_key":"external-user-2"} +{"kind":"ep_recon"} +{"kind":"ep_copy","scope_key":"external-group-1"} +{"kind":"ep_copy","scope_key":"external-user-1"} +{"kind":"ep_copy","scope_key":"external-user-2"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"ep_list"} +{"kind":"ep_live","scope_key":"external-group-1"} +{"kind":"ep_live","scope_key":"external-user-2"} +{"kind":"ep_copy","scope_key":"external-group-1"} +{"kind":"ep_copy","scope_key":"external-user-2"} +{"kind":"checkpoint"} +{"kind":"seal"} diff --git a/formal/occult/host/testdata/realtraces/warm_replay_sync.jsonl b/formal/occult/host/testdata/realtraces/warm_replay_sync.jsonl new file mode 100644 index 000000000..55120b248 --- /dev/null +++ b/formal/occult/host/testdata/realtraces/warm_replay_sync.jsonl @@ -0,0 +1,9 @@ +{"name":"warm_replay_sync","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"consult","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"replay","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"publish","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"checkpoint"} +{"kind":"seal"} diff --git a/formal/occult/host/testdata/realtraces/warm_replay_sync_interrupted.jsonl b/formal/occult/host/testdata/realtraces/warm_replay_sync_interrupted.jsonl new file mode 100644 index 000000000..8a895ad56 --- /dev/null +++ b/formal/occult/host/testdata/realtraces/warm_replay_sync_interrupted.jsonl @@ -0,0 +1,26 @@ +{"name":"warm_replay_sync_interrupted","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"consult","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"replay","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"upsert","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"consult","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"replay","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"upsert","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"publish","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"checkpoint"} +{"kind":"seal"} diff --git a/formal/occult/host/testdata/realtraces/warm_replay_sync_record_flip.jsonl b/formal/occult/host/testdata/realtraces/warm_replay_sync_record_flip.jsonl new file mode 100644 index 000000000..6f59a368d --- /dev/null +++ b/formal/occult/host/testdata/realtraces/warm_replay_sync_record_flip.jsonl @@ -0,0 +1,25 @@ +{"name":"warm_replay_sync_record_flip","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"consult","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"replay","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"upsert","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"consult","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"upsert","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"publish","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"checkpoint"} +{"kind":"seal"} diff --git a/formal/occult/host/testdata/realtraces/warm_replay_sync_session_zombie.jsonl b/formal/occult/host/testdata/realtraces/warm_replay_sync_session_zombie.jsonl new file mode 100644 index 000000000..d5e212c9f --- /dev/null +++ b/formal/occult/host/testdata/realtraces/warm_replay_sync_session_zombie.jsonl @@ -0,0 +1,11 @@ +{"name":"warm_replay_sync_session_zombie","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"consult","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"replay","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"upsert","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"swrite","scope_key":"probe-key"} +{"kind":"resume"} +{"kind":"checkpoint"} +{"kind":"sread_hit","scope_key":"probe-key"} diff --git a/formal/occult/host/testdata/realtraces/warm_replay_sync_tombstone.jsonl b/formal/occult/host/testdata/realtraces/warm_replay_sync_tombstone.jsonl new file mode 100644 index 000000000..584235be2 --- /dev/null +++ b/formal/occult/host/testdata/realtraces/warm_replay_sync_tombstone.jsonl @@ -0,0 +1,11 @@ +{"name":"warm_replay_sync_tombstone","resumed":false} +{"kind":"checkpoint"} +{"kind":"checkpoint"} +{"kind":"consult","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"clear","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"replay","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"upsert","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"delete","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"publish","row_kind":"grants","scope_key":"grants:team-1"} +{"kind":"checkpoint"} +{"kind":"seal"} diff --git a/formal/occult/host/trace_policies_test.go b/formal/occult/host/trace_policies_test.go new file mode 100644 index 000000000..f05efe0b1 --- /dev/null +++ b/formal/occult/host/trace_policies_test.go @@ -0,0 +1,143 @@ +// Deliverable 7: the trace-policy oracle set +// (../src/sync_trace_policies.occult) checked as a full verdict matrix +// — every policy against every fixture. Green fixtures must satisfy +// all seven policies; each red fixture must violate EXACTLY its own +// policy and satisfy the other six, so a policy that silently accepts +// everything (or rejects everything) cannot pass. +package host_test + +import ( + "context" + "fmt" + "testing" + + occult "github.com/conductorone/occult" + "github.com/conductorone/occult/state" +) + +// policyVerdictTerm evaluates one policy applied to a trace TERM +// (any expression over the module's constructors, module handle "M") +// and returns the engine's verdict string. +func policyVerdictTerm(t *testing.T, policy, term string) string { + t.Helper() + interp, pm, err := occult.NewCLIInterpreter("egraph", false, "", "") + if err != nil { + t.Fatalf("NewCLIInterpreter: %v", err) + } + if _, err := interp.LoadStdlib("sync_trace_policies", readSrc(t, "sync_trace_policies.occult"), pm); err != nil { + t.Fatalf("LoadStdlib sync_trace_policies: %v", err) + } + source := fmt.Sprintf(`M = require("sync_trace_policies"); M.%s(%s)`, policy, term) + res, err := interp.Eval(context.Background(), "policy-check", source, pm) + if err != nil { + t.Fatalf("Eval %q: %v", source, err) + } + if res == nil || res.Loc == nil { + t.Fatalf("Eval %q: no result location", source) + } + st, ok := interp.State.Resolve(*res.Loc) + if !ok || st.Literal == nil || st.Literal.Kind != state.LitString { + t.Fatalf("Eval %q: verdict did not reduce to a string", source) + } + return st.Literal.Str +} + +// policyVerdict evaluates one policy applied to one named fixture trace. +func policyVerdict(t *testing.T, policy, trace string) string { + t.Helper() + return policyVerdictTerm(t, policy, "M."+trace) +} + +var policies = []string{ + "consult_before_replay", + "clear_before_upsert", + "once_per_scope", + "checkpoint_before_progress", + "seal_obligations", + "session_ckpt_consistency", + "external_principal_grounding", +} + +// fixtureViolates maps each fixture to the single policy it violates +// ("" = none: the green trace). +var fixtureViolates = map[string]string{ + "trace_green": "", + "trace_red_cbr": "consult_before_replay", + "trace_red_cbu": "clear_before_upsert", + "trace_red_ops": "once_per_scope", + "trace_red_cbp": "checkpoint_before_progress", + "trace_red_seal": "seal_obligations", + "trace_green_resume": "", + "trace_red_ops_resume": "once_per_scope", + "trace_green_delete": "", + "trace_red_cbu_del": "clear_before_upsert", + "trace_red_cbp_del": "checkpoint_before_progress", + "trace_red_seal_del": "seal_obligations", + // Session fixtures (policy 6, session-checkpoint consistency — the + // CO-6b-009 root cause). The two reds violate the SAME policy in + // its two directions; fixtureVerdict carries the exact string. + "trace_green_session": "", + "trace_green_session_rollback": "", + "trace_red_session_zombie": "session_ckpt_consistency", + "trace_red_session_amnesia": "session_ckpt_consistency", + // External-principal fixtures (policy 7, external-principal + // grounding — the deleteStaleExternalPrincipals contract). The two + // reds violate the SAME policy in its two directions; + // fixtureVerdict carries the exact string. + "trace_green_ext": "", + "trace_green_ext_carry": "", + "trace_red_ext_norecon": "external_principal_grounding", + "trace_red_ext_stale": "external_principal_grounding", +} + +// fixtureVerdict overrides the expected violation string for fixtures +// whose policy distinguishes violation directions. +var fixtureVerdict = map[string]string{ + "trace_red_session_zombie": "violation: session-zombie-read", + "trace_red_session_amnesia": "violation: session-amnesia", + "trace_red_ext_norecon": "violation: ext-recon-before-copy", + "trace_red_ext_stale": "violation: ext-stale-survivor", +} + +func TestTracePolicyMatrix(t *testing.T) { + for fixture, violated := range fixtureViolates { + for _, policy := range policies { + t.Run(fixture+"/"+policy, func(t *testing.T) { + verdict := policyVerdict(t, policy, fixture) + if policy == violated { + want := "violation: " + policyLabel(policy) + if v, ok := fixtureVerdict[fixture]; ok { + want = v + } + if verdict != want { + t.Errorf("expected %s to violate %s with %q, got verdict %q", fixture, policy, want, verdict) + } + } else { + if verdict != "ok" { + t.Errorf("expected %s to satisfy %s, got verdict %q", fixture, policy, verdict) + } + } + }) + } + } +} + +func policyLabel(policy string) string { + switch policy { + case "consult_before_replay": + return "consult-before-replay" + case "clear_before_upsert": + return "clear-before-upsert" + case "once_per_scope": + return "once-per-scope" + case "checkpoint_before_progress": + return "checkpoint-before-progress" + case "seal_obligations": + return "seal-obligations" + case "session_ckpt_consistency": + return "session-ckpt-consistency" + case "external_principal_grounding": + return "external-principal-grounding" + } + return policy +} diff --git a/formal/occult/src/sync_fixtures.occult b/formal/occult/src/sync_fixtures.occult new file mode 100644 index 000000000..008b519e0 --- /dev/null +++ b/formal/occult/src/sync_fixtures.occult @@ -0,0 +1,9 @@ +# Free Skolem constants for the law checks: no axiom mentions them, so +# a law verified on them holds for arbitrary values (fresh-constant +# argument). Both sides of every equivalence query reference THE SAME +# module existential, which is what makes the two independently loaded +# query modules talk about one entity. + +∃ e1; ∃ e2; ∃ e3; +∃ x0; ∃ y0; ∃ g0; +∃ v0; ∃ m0; ∃ op0; diff --git a/formal/occult/src/sync_laws.occult b/formal/occult/src/sync_laws.occult new file mode 100644 index 000000000..dd020bc06 --- /dev/null +++ b/formal/occult/src/sync_laws.occult @@ -0,0 +1,87 @@ +# Composition algebra of the P1 fold (formal/MODEL_SPEC.md §7) and the +# variant-S stamp facts (formal/GRAPH_MODEL_SPEC.md). Loaded into +# UniversalScope by the host (LoadStdlib): bare identifiers in equation +# bodies are universal pattern variables; operations and constructors +# are existentials. Every pattern is head-guarded by a constructor. +# +# These equations are the DEFINITIONS (the fold clauses and the +# dead-membership homomorphism). The laws in formal/occult/LAWS.md are +# checked as derived equivalences by the host (host/laws_test.go); +# nothing here states a law as its own assumption. +# +# CONSTRAINT DISCIPLINE (lint: unconstrained-axiom-universal). The +# universals here range over OPEN carriers by design: the laws are +# verified on the free Skolem constants of sync_fixtures.occult, and +# the fresh-constant argument needs those constants free of axioms — +# gating the fold clauses on sorts would demand membership facts about +# the Skolems, and the engine cannot consume userspace free-term +# membership at dispatch anyway (host/constrained_params_probe_test.go +# pins this). This is also why the L7 ACI axioms below COPY the shape +# of the stdlib's vc_merge instead of requiring std vector_clock: that +# module's universals are constrained to a VectorClock sort nothing +# gives members, so its rewrites cannot fire on our stamp terms. + +# --- Fold values and complete-round operations --- + +∃ app; ∃ foldops; +∃ rows; +∃ fresh; ∃ repl; ∃ ovl; ∃ ovlsg; ∃ skip; +∃ opsnil; ∃ opscons; + +# Fold clauses (MODEL_SPEC §7, P1): +# fresh(e): fetch-fresh / REPLACES round — absorbs any prior fold value. +app(fresh(e), x) = rows(e); +# repl(e): completed replacement copy of the attested base e. +app(repl(e), x) = rows(e); +# ovlsg(e): self-grounding overlay (its own copy committed in-round). +app(ovlsg(e), x) = rows(e); +# ovl(a, b): overlay grounded on this sync's completed replay of a. +app(ovl(a, b), rows(a)) = rows(b); +# skip(e): copy-skipped duplicate — a no-op on the already-current value. +app(skip(e), rows(e)) = rows(e); + +# Round-log fold: ops apply in completion order (head first). +foldops(opsnil, x) = x; +foldops(opscons(op, rest), x) = foldops(rest, app(op, x)); + +# --- Row-map observations (two-id envelope, for the tombstone laws) --- +# Distinct ids are distinct constructors: the coalesced-delta +# precondition (at most one op per id per round) makes a two-id +# observational algebra sufficient for the commutation law. + +∃ get; ∃ put; ∃ del; +∃ id1; ∃ id2; +∃ found; ∃ absent; + +get(id1, put(id1, v, m)) = found(v); +get(id2, put(id2, v, m)) = found(v); +get(id1, del(id1, m)) = absent; +get(id2, del(id2, m)) = absent; +get(id1, put(id2, v, m)) = get(id1, m); +get(id2, put(id1, v, m)) = get(id2, m); +get(id1, del(id2, m)) = get(id1, m); +get(id2, del(id1, m)) = get(id2, m); + +# --- Stamps: dead-membership homomorphism (variant S) --- +# Own booleans (tt/ff) keep the algebra free-constructor: natives are +# opaque to saturation. + +∃ merge; ∃ dead; ∃ live; +∃ hasdead; ∃ tt; ∃ ff; ∃ bor; + +bor(tt, b) = tt; +bor(b, tt) = tt; +bor(ff, ff) = ff; + +hasdead(dead(g)) = tt; +hasdead(live(g)) = ff; +hasdead(merge(a, b)) = bor(hasdead(a), hasdead(b)); + +# L7 — the join-semilattice ASSUMPTIONS for merge, instantiating the +# engine stdlib's vector_clock axioms (vc_merge) on our stamp carrier. +# These are assumptions of the design, not theorems here; they are +# loaded so every other law is checked IN THEIR PRESENCE (coherence: +# the controls must stay non-equivalent even with ACI closure active). +merge(a, b) = merge(b, a); +merge(a, merge(b, c)) = merge(merge(a, b), c); +merge(a, a) = a; diff --git a/formal/occult/src/sync_phantom.occult b/formal/occult/src/sync_phantom.occult new file mode 100644 index 000000000..048ce1571 --- /dev/null +++ b/formal/occult/src/sync_phantom.occult @@ -0,0 +1,75 @@ +# The phantom union, derived deductively (the KNOWN-BROKEN composition +# vs the premise-validated one). This is the walker calibration +# family's star bug (formal/MODEL_SPEC.md; brief "Calibration cases"): +# a source-cache replay grounds the partition at the cache's ATTESTED +# epoch (e0), but the broken algorithm requests the overlay diff from +# the LAST SYNC's epoch (e1). Each response is individually truthful — +# the replay really is rows(e0), the diff really is e1→e2 — and their +# composition is false: a row deleted between e0 and e1 survives as a +# phantom. The good algorithm (demand-graph runtime / premise-validated +# adoption) grounds the diff at the marker's attested base, so the same +# ingredients compose truthfully. +# +# Upstream history (two-id observational envelope, as in sync_laws): +# e0: id1 = vx, id2 = v1 +# e1: id1 DELETED, id2 = v1 +# e2: id1 absent, id2 = v2 +# The truthful diff e1→e2 mentions only id2 (id1 did not change between +# e1 and e2 — it was already gone). The truthful diff e0→e2 mentions +# both. Applying diff12 to the e0-grounded base is the bug. +# +# CONSTRAINT DISCIPLINE (lint: unconstrained-axiom-universal): the +# universals v/m/b are deliberately unconstrained — head-guarded by +# module-local constructors (get/put/del), and the engine cannot yet +# consume userspace free-term membership at axiom dispatch (pinned by +# host/constrained_params_probe_test.go; see the engine-changes brief). + +syntax("standard"); + +# Row-map observations (self-contained copy of the two-id algebra). +∃ get; +∃ put; +∃ del; +∃ mt; +∃ id1; +∃ id2; +∃ found; +∃ absent; + +get(id1, mt) = absent; +get(id2, mt) = absent; +get(id1, put(id1, v, m)) = found(v); +get(id2, put(id2, v, m)) = found(v); +get(id1, del(id1, m)) = absent; +get(id2, del(id2, m)) = absent; +get(id1, put(id2, v, m)) = get(id1, m); +get(id2, put(id1, v, m)) = get(id2, m); +get(id1, del(id2, m)) = get(id1, m); +get(id2, del(id1, m)) = get(id2, m); + +# Upstream truth per epoch. +∃ vx; +∃ v1; +∃ v2; +∃ rows_e0; +∃ rows_e1; +∃ rows_e2; +rows_e0 = put(id1, vx, put(id2, v1, mt)); +rows_e1 = put(id2, v1, mt); +rows_e2 = put(id2, v2, mt); + +# Truthful diffs as base transformers. diff12 is truthful FOR BASE e1; +# diff02 is truthful for base e0. +∃ diff12; +∃ diff02; +diff12(b) = put(id2, v2, b); +diff02(b) = put(id2, v2, del(id1, b)); + +# The two compositions under test. broken: replay grounded at e0, diff +# requested from e1 (the composition the current algorithm can +# produce). good: diff grounded at the replay's attested base (what +# premise-validated adoption enforces). +∃ result_broken; +∃ result_good; +result_broken = diff12(rows_e0); +result_good = diff02(rows_e0); diff --git a/formal/occult/src/sync_protocol.occult b/formal/occult/src/sync_protocol.occult new file mode 100644 index 000000000..a63d762e0 --- /dev/null +++ b/formal/occult/src/sync_protocol.occult @@ -0,0 +1,75 @@ +# Deliverable 8: the syncer↔connector source-cache protocol as a global +# session term with per-role projections (brief: "Session-typed protocol +# contract"). Contract source: +# proto/c1/connector/v2/annotation_source_cache.proto (lookup +# continuation: offer→ask→answers with a per-request bounce cap of 4; +# replay/record annotation exchange on page responses). +# +# Role mapping: SYNCER = P_leader, CONNECTOR = P_follower (send(d) is +# syncer→connector; recv(d) is connector→syncer — the projection +# functor's polarity). +# +# The bounce cap is STRUCTURAL: the module defines sessions with at +# most four ask rounds and no five-bounce term exists here. Checking a +# cap VIOLATION (or general stuck-freedom) is the engine's open +# session-types work; until then the cap lives in the protocol shape, +# and the Go-side constant it mirrors is +# sourcecache.MaxLookupBouncesPerRequest = 4. +# +# Fidelity note: local(e) is role-unannotated in the projection functor +# (both projections carry it). resolve_answers is syncer-local in +# reality; the connector's projected local(resolve_answers) is vacuous. + +syntax("standard"); + +∃ proto; +proto = require("protocol"); +∃ send; +send = proto.send; +∃ recv; +recv = proto.recv; + +∃ proj; +proj = require("projection"); +∃ local; +local = proj.local; + +# Message tags: +# req_offer — list request carrying SourceCacheLookupOffer. +# req_answers — the SAME request re-invoked with accumulated +# SourceCacheLookupAnswers (still carrying the offer). +# lookup_ask — response carrying SourceCacheLookupAsk: no rows, no token. +# page_record — page response: fresh rows + SourceCacheRecord. +# page_replay — page response: no rows + SourceCacheReplay (overlay +# pages follow as records). +# resolve_answers — syncer-local: resolve asks against the previous +# artifact. +∃ req_offer; +∃ req_answers; +∃ lookup_ask; +∃ page_record; +∃ page_replay; +∃ resolve_answers; + +# Ask bounces as CLOSED terms (the raft shape: parameterized protocol +# functions gate their rewrite on classifier membership of the +# argument, which free message tags do not carry). ask_first is the +# initial request's bounce; ask_again is a re-invoked request's bounce. +∃ ask_first; +∃ ask_again; +ask_first = send(req_offer) pipe recv(lookup_ask) pipe local(resolve_answers); +ask_again = send(req_answers) pipe recv(lookup_ask) pipe local(resolve_answers); + +# Sessions per request (record leg; the replay legs are symmetric): +# session_direct — no ask: the offer is honored, the page served +# immediately; session_ask1 — one bounce; session_ask4 — the maximal +# legal session (bounce cap 4). +∃ session_direct; +∃ session_ask1; +∃ session_ask4; +∃ session_direct_replay; + +session_direct = send(req_offer) pipe recv(page_record); +session_direct_replay = send(req_offer) pipe recv(page_replay); +session_ask1 = ask_first pipe send(req_answers) pipe recv(page_record); +session_ask4 = ask_first pipe ask_again pipe ask_again pipe ask_again pipe send(req_answers) pipe recv(page_record); diff --git a/formal/occult/src/sync_trace_policies.occult b/formal/occult/src/sync_trace_policies.occult new file mode 100644 index 000000000..7ecdef963 --- /dev/null +++ b/formal/occult/src/sync_trace_policies.occult @@ -0,0 +1,501 @@ +# Deliverable 7: the ordering/durability trace-policy oracle set +# (brief: "Trace-policy oracle set" — consult-before-replay, +# checkpoint-before-progress, clear-before-upsert, once-per-scope, seal +# obligations, policy 6: session-checkpoint consistency (the CO-6b-009 +# root cause), plus policy 7: external-principal grounding, the +# deleteStaleExternalPrincipals contract) over the announce vocabulary +# pinned in formal/MODEL_SPEC.md §7. A trace is ONE SYNC's event list — possibly +# spanning crash/resume attempts, with ev_resume marking each attempt +# boundary (the multi-attempt extension; single-attempt traces carry no +# marker and mean exactly what they did before). Each policy is a +# recursive verdict function returning "ok" or a violation string. Two +# scopes (s1, s2) — the same small-scope envelope as the P models. +# +# Loaded into UniversalScope by the host: equations are rewrite rules, +# bare identifiers (r, a, b, p, q, s, v) are universal pattern +# variables, and every pattern is head-guarded by a constructor. +# +# CONSTRAINT DISCIPLINE (lint: unconstrained-axiom-universal). Every +# universal here is deliberately unconstrained. The prescribed fix — +# gating the scope/flag universals on userspace sorts (s : Scope; with +# Scope = {s1, s2,}) — does not evaluate today: axiom-side dispatch +# cannot consume free-term classifier membership in any documented form, +# so member-only traces stop reducing and every verdict becomes a stuck +# term (pinned by host/constrained_params_probe_test.go; the ask lives +# in docs/tasks/occult-engine-changes-brief.md). Until the engine lands +# that evidence, the mitigation is the head-guard discipline: every LHS +# is guarded by a module-local constructor (tcons/tnil/ev_*), so a +# universal binds only inside applications of this module's own +# existentials — the cross-model bridged-class hazard the lint warns +# about requires someone bridging these heads, which the host never +# does. + +syntax("standard"); + +# Events. ev_replay(s) is the committed replacement copy for scope s +# (the replay-unit commit); ev_clear(s) the partition clear; +# ev_checkpoint the durable watermark commit; ev_seal the artifact +# seal. +∃ ev_consult; +∃ ev_clear; +∃ ev_replay; +∃ ev_upsert; +∃ ev_publish; +∃ ev_checkpoint; +∃ ev_seal; + +# ev_delete(s) is a committed tombstone application for scope s (the +# delta protocol's delete leg: DeletedIds / DeletedPrincipalIds applied +# by the store after the page's rows, before the validator publish — +# B3's within-page order). A delete is a WRITE: it needs grounding like +# an upsert (a tombstone against an un-regrounded base is the same bug +# class — you cannot delete from a base that was never copied), it +# dirties the quiescent-checkpoint flag, and it marks the scope active +# for seal obligations. Consult-before-replay and once-per-scope ignore +# it. +∃ ev_delete; + +# Session-store events (policy 6). ev_swrite(k) is a committed +# connector session write for key k; ev_sread_hit(k) / ev_sread_miss(k) +# a session read returning found / not-found. Sessions commit durably +# at op time, OUTSIDE the checkpoint mechanism — which is exactly the +# hazard policy 6 exists to judge. Session events are invisible to the +# artifact policies (1-5): they are not partition writes, do not need +# grounding, and do not dirty the quiescent-checkpoint watermark. +# One-key envelope (k1), mirroring the P model's single session key. +∃ ev_swrite; +∃ ev_sread_hit; +∃ ev_sread_miss; +∃ k1; + +# External-principal events (policy 7). The external phase copies an +# outside source's principals into the sync store; committed copies +# are durable across crashes (checkpoint resume deliberately retains +# completed writes), so a between-attempt shrink strands a dead +# attempt's copies unless reconciliation deletes them. ep_list marks a +# phase run listing the source's CURRENT answer; ep_live(p) declares p +# a member of that answer; ep_recon marks reconciliation COMPLETED +# (stale copies deleted, or nothing stale — the warn-and-continue +# degrade of a non-deleting engine emits NO ep_recon: the pass ran but +# did not reconcile); ep_copy(p) is p's committed principal write. +# External events live in their own keyspace: invisible to the +# artifact policies (1-5) and the session policy (6), like session +# events are to both. Two-principal envelope (p1, p2), mirroring the +# P model's scenario-8 row ids. +∃ ep_list; +∃ ep_live; +∃ ep_recon; +∃ ep_copy; +∃ p1; +∃ p2; + +# ev_resume marks a crash/resume attempt boundary inside one sync's +# trace. Semantics (matching pkg/sync's checkpoint-durable provenance, +# pinned by chaos_source_cache_resume_test.go): durable facts PERSIST +# across the boundary — consult flags (the hit-set is +# checkpoint-durable), clear grounding (committed rows survive the +# crash), scope activity and publishes (seal obligations are +# sync-scoped). Only once-per-scope RESETS: an interrupted action +# restarts from its root token, so the across-attempt replay re-copy is +# B5-legal at-least-once idempotence, while a within-attempt duplicate +# remains the bug the policy exists to catch. The quiescent-checkpoint +# flag also persists: a resume adds no progress by itself. +∃ ev_resume; + +# Scopes and trace list constructors. +∃ s1; +∃ s2; +∃ tnil; +∃ tcons; + +# Flag booleans (free constructors; natives are opaque to saturation). +∃ tt; +∃ ff; + +# --- Policy 1: consult-before-replay --- +# Every replay commit for a scope requires an earlier source-cache +# consult for that scope in the same attempt. +∃ consult_before_replay; +∃ cbr_go; +consult_before_replay(t) = cbr_go(t, ff, ff); +cbr_go(tnil, a, b) = "ok"; +cbr_go(tcons(ev_consult(s1), r), a, b) = cbr_go(r, tt, b); +cbr_go(tcons(ev_consult(s2), r), a, b) = cbr_go(r, a, tt); +cbr_go(tcons(ev_replay(s1), r), tt, b) = cbr_go(r, tt, b); +cbr_go(tcons(ev_replay(s1), r), ff, b) = "violation: consult-before-replay"; +cbr_go(tcons(ev_replay(s2), r), a, tt) = cbr_go(r, a, tt); +cbr_go(tcons(ev_replay(s2), r), a, ff) = "violation: consult-before-replay"; +cbr_go(tcons(ev_clear(s), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_upsert(s), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_publish(s), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_checkpoint, r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_seal, r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_resume, r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_delete(s), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_swrite(k), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_sread_hit(k), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ev_sread_miss(k), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ep_list, r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ep_live(p), r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ep_recon, r), a, b) = cbr_go(r, a, b); +cbr_go(tcons(ep_copy(p), r), a, b) = cbr_go(r, a, b); + +# --- Policy 2: clear-before-upsert (clear-before-WRITE) --- +# Any upsert into — or tombstone delete from — a scope's partition +# requires an earlier clear of that partition (replacement rounds clear +# first; overlay upserts and deletes are grounded on this sync's +# replay, which cleared). The policy name and violation string keep the +# original "upsert" form for continuity; the gate covers both write +# kinds. +∃ clear_before_upsert; +∃ cbu_go; +clear_before_upsert(t) = cbu_go(t, ff, ff); +cbu_go(tnil, a, b) = "ok"; +cbu_go(tcons(ev_clear(s1), r), a, b) = cbu_go(r, tt, b); +cbu_go(tcons(ev_clear(s2), r), a, b) = cbu_go(r, a, tt); +cbu_go(tcons(ev_upsert(s1), r), tt, b) = cbu_go(r, tt, b); +cbu_go(tcons(ev_upsert(s1), r), ff, b) = "violation: clear-before-upsert"; +cbu_go(tcons(ev_upsert(s2), r), a, tt) = cbu_go(r, a, tt); +cbu_go(tcons(ev_upsert(s2), r), a, ff) = "violation: clear-before-upsert"; +cbu_go(tcons(ev_delete(s1), r), tt, b) = cbu_go(r, tt, b); +cbu_go(tcons(ev_delete(s1), r), ff, b) = "violation: clear-before-upsert"; +cbu_go(tcons(ev_delete(s2), r), a, tt) = cbu_go(r, a, tt); +cbu_go(tcons(ev_delete(s2), r), a, ff) = "violation: clear-before-upsert"; +cbu_go(tcons(ev_consult(s), r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_replay(s), r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_publish(s), r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_checkpoint, r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_seal, r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_resume, r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_swrite(k), r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_sread_hit(k), r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ev_sread_miss(k), r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ep_list, r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ep_live(p), r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ep_recon, r), a, b) = cbu_go(r, a, b); +cbu_go(tcons(ep_copy(p), r), a, b) = cbu_go(r, a, b); + +# --- Policy 3: once-per-scope --- +# At most one committed replacement copy per scope per attempt (the +# across-attempt idempotent re-run is B5-legal and lives outside a +# single-attempt trace). +∃ once_per_scope; +∃ ops_go; +once_per_scope(t) = ops_go(t, ff, ff); +ops_go(tnil, a, b) = "ok"; +ops_go(tcons(ev_replay(s1), r), ff, b) = ops_go(r, tt, b); +ops_go(tcons(ev_replay(s1), r), tt, b) = "violation: once-per-scope"; +ops_go(tcons(ev_replay(s2), r), a, ff) = ops_go(r, a, tt); +ops_go(tcons(ev_replay(s2), r), a, tt) = "violation: once-per-scope"; +ops_go(tcons(ev_consult(s), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_clear(s), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_upsert(s), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_publish(s), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_checkpoint, r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_seal, r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_resume, r), a, b) = ops_go(r, ff, ff); +ops_go(tcons(ev_delete(s), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_swrite(k), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_sread_hit(k), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ev_sread_miss(k), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ep_list, r), a, b) = ops_go(r, a, b); +ops_go(tcons(ep_live(p), r), a, b) = ops_go(r, a, b); +ops_go(tcons(ep_recon, r), a, b) = ops_go(r, a, b); +ops_go(tcons(ep_copy(p), r), a, b) = ops_go(r, a, b); + +# --- Policy 4: checkpoint-before-progress (seal form) --- +# The seal requires a QUIESCENT checkpoint: an ev_checkpoint after +# which no write event (clear/replay/upsert/publish) occurred. Reads +# do not dirty the watermark. +∃ checkpoint_before_progress; +∃ cbp_go; +checkpoint_before_progress(t) = cbp_go(t, ff); +cbp_go(tnil, f) = "ok"; +cbp_go(tcons(ev_checkpoint, r), f) = cbp_go(r, tt); +cbp_go(tcons(ev_clear(s), r), f) = cbp_go(r, ff); +cbp_go(tcons(ev_replay(s), r), f) = cbp_go(r, ff); +cbp_go(tcons(ev_upsert(s), r), f) = cbp_go(r, ff); +cbp_go(tcons(ev_delete(s), r), f) = cbp_go(r, ff); +cbp_go(tcons(ev_publish(s), r), f) = cbp_go(r, ff); +cbp_go(tcons(ev_consult(s), r), f) = cbp_go(r, f); +cbp_go(tcons(ev_resume, r), f) = cbp_go(r, f); +cbp_go(tcons(ev_swrite(k), r), f) = cbp_go(r, f); +cbp_go(tcons(ev_sread_hit(k), r), f) = cbp_go(r, f); +cbp_go(tcons(ev_sread_miss(k), r), f) = cbp_go(r, f); +cbp_go(tcons(ep_list, r), f) = cbp_go(r, f); +cbp_go(tcons(ep_live(p), r), f) = cbp_go(r, f); +cbp_go(tcons(ep_recon, r), f) = cbp_go(r, f); +cbp_go(tcons(ep_copy(p), r), f) = cbp_go(r, f); +cbp_go(tcons(ev_seal, r), tt) = "ok"; +cbp_go(tcons(ev_seal, r), ff) = "violation: checkpoint-before-progress"; + +# --- Policy 5: seal obligations --- +# Every scope with any activity this attempt (consult/clear/replay/ +# upsert) must be published before the seal. State per scope: active +# flag, published flag. +∃ seal_obligations; +∃ so_go; +seal_obligations(t) = so_go(t, ff, ff, ff, ff); +so_go(tnil, a, p, b, q) = "ok"; +so_go(tcons(ev_consult(s1), r), a, p, b, q) = so_go(r, tt, p, b, q); +so_go(tcons(ev_consult(s2), r), a, p, b, q) = so_go(r, a, p, tt, q); +so_go(tcons(ev_clear(s1), r), a, p, b, q) = so_go(r, tt, p, b, q); +so_go(tcons(ev_clear(s2), r), a, p, b, q) = so_go(r, a, p, tt, q); +so_go(tcons(ev_replay(s1), r), a, p, b, q) = so_go(r, tt, p, b, q); +so_go(tcons(ev_replay(s2), r), a, p, b, q) = so_go(r, a, p, tt, q); +so_go(tcons(ev_upsert(s1), r), a, p, b, q) = so_go(r, tt, p, b, q); +so_go(tcons(ev_upsert(s2), r), a, p, b, q) = so_go(r, a, p, tt, q); +so_go(tcons(ev_delete(s1), r), a, p, b, q) = so_go(r, tt, p, b, q); +so_go(tcons(ev_delete(s2), r), a, p, b, q) = so_go(r, a, p, tt, q); +so_go(tcons(ev_publish(s1), r), a, p, b, q) = so_go(r, a, tt, b, q); +so_go(tcons(ev_publish(s2), r), a, p, b, q) = so_go(r, a, p, b, tt); +so_go(tcons(ev_checkpoint, r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ev_resume, r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ev_swrite(k), r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ev_sread_hit(k), r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ev_sread_miss(k), r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ep_list, r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ep_live(x), r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ep_recon, r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ep_copy(x), r), a, p, b, q) = so_go(r, a, p, b, q); +so_go(tcons(ev_seal, r), tt, ff, b, q) = "violation: seal-obligations"; +so_go(tcons(ev_seal, r), a, p, tt, ff) = "violation: seal-obligations"; +so_go(tcons(ev_seal, r), ff, p, ff, q) = "ok"; +so_go(tcons(ev_seal, r), tt, tt, ff, q) = "ok"; +so_go(tcons(ev_seal, r), ff, p, tt, tt) = "ok"; +so_go(tcons(ev_seal, r), tt, tt, tt, tt) = "ok"; + +# --- Policy 6: session-checkpoint consistency --- +# THE CONSTRAINT (CO-6b-009's root cause; the P model's P6-C monitor +# in trace-policy form): observable session state after a crash/resume +# boundary must equal session state at the restored checkpoint — in +# BOTH directions. +# ZOMBIE: a session write with no later checkpoint before ev_resume +# belongs to the dead attempt's rolled-back window; a read HIT on +# that key afterwards (with no committed value it could be +# shadowing, and no live rewrite) observed the dead attempt's +# future. +# AMNESIA: a checkpoint-committed session value must remain readable +# — the work that produced it will NOT re-run, so a read MISS is +# unrecoverable data loss (the rejected wholesale resume-clear). +# State per key: u = written since the last checkpoint, c = a +# checkpoint committed some value, z = a dead attempt's uncommitted +# write is (potentially) still durable. A live rewrite reclaims the +# key (z := ff). Value-blind conservatism: a HIT with c = tt AND +# z = tt cannot be judged without values (the durable zombie may +# shadow the committed value) and passes here — the P model's +# value-aware P6-C covers that case. +∃ session_ckpt_consistency; +∃ scc_go; +session_ckpt_consistency(t) = scc_go(t, ff, ff, ff); +scc_go(tnil, u, c, z) = "ok"; +scc_go(tcons(ev_swrite(k1), r), u, c, z) = scc_go(r, tt, c, ff); +scc_go(tcons(ev_checkpoint, r), tt, c, z) = scc_go(r, ff, tt, z); +scc_go(tcons(ev_checkpoint, r), ff, c, z) = scc_go(r, ff, c, z); +scc_go(tcons(ev_resume, r), tt, c, z) = scc_go(r, ff, c, tt); +scc_go(tcons(ev_resume, r), ff, c, z) = scc_go(r, ff, c, z); +scc_go(tcons(ev_sread_hit(k1), r), u, c, ff) = scc_go(r, u, c, ff); +scc_go(tcons(ev_sread_hit(k1), r), u, tt, tt) = scc_go(r, u, tt, tt); +scc_go(tcons(ev_sread_hit(k1), r), u, ff, tt) = "violation: session-zombie-read"; +scc_go(tcons(ev_sread_miss(k1), r), u, tt, z) = "violation: session-amnesia"; +scc_go(tcons(ev_sread_miss(k1), r), u, ff, z) = scc_go(r, u, ff, z); +scc_go(tcons(ev_consult(s), r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ev_clear(s), r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ev_replay(s), r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ev_upsert(s), r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ev_delete(s), r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ev_publish(s), r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ev_seal, r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ep_list, r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ep_live(x), r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ep_recon, r), u, c, z) = scc_go(r, u, c, z); +scc_go(tcons(ep_copy(x), r), u, c, z) = scc_go(r, u, c, z); + +# --- Policy 7: external-principal grounding --- +# THE CONSTRAINT (the deleteStaleExternalPrincipals contract; the P +# model's P8 monitor in trace-policy form). Committed principal copies +# are durable across crashes, so a dead attempt's copies are debris +# the moment the source's answer shrinks. Two directions: +# RECON-BEFORE-COPY: within a phase run (ep_list starts one), the +# current answer's writes may commit only after reconciliation +# completed (ep_recon) — the warn-and-continue degrade of a +# non-deleting engine copies over unreconciled debris and emits no +# ep_recon, so its first copy is the violation. +# STALE-SURVIVOR at seal: a principal copied this sync but absent +# from the last-listed answer survived to seal undeleted (and, +# dually, EXT-MISSING: a listed principal never copied). The seal +# clause compares against the last LIST, not truth-at-seal — an +# attempt that completed the phase before a crash seals its own +# answer legitimately (sync-scoped freshness). +# State: n = reconciliation completed this phase run (reset by +# ep_list), c1/c2 = principal copied and not reconciled away (durable +# — never reset by ep_list or ev_resume), l1/l2 = member of the +# current answer (reset by ep_list). ep_recon deletes stale copies: +# c := c AND l. Value-blind like every policy here; the P monitor +# carries the truth ghost this trace form cannot. +∃ band; +band(tt, tt) = tt; +band(tt, ff) = ff; +band(ff, tt) = ff; +band(ff, ff) = ff; +∃ external_principal_grounding; +∃ epg_go; +external_principal_grounding(t) = epg_go(t, ff, ff, ff, ff, ff); +epg_go(tnil, n, c1, c2, l1, l2) = "ok"; +epg_go(tcons(ep_list, r), n, c1, c2, l1, l2) = epg_go(r, ff, c1, c2, ff, ff); +epg_go(tcons(ep_live(p1), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, tt, l2); +epg_go(tcons(ep_live(p2), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, tt); +epg_go(tcons(ep_recon, r), n, c1, c2, l1, l2) = epg_go(r, tt, band(c1, l1), band(c2, l2), l1, l2); +epg_go(tcons(ep_copy(p1), r), tt, c1, c2, l1, l2) = epg_go(r, tt, tt, c2, l1, l2); +epg_go(tcons(ep_copy(p1), r), ff, c1, c2, l1, l2) = "violation: ext-recon-before-copy"; +epg_go(tcons(ep_copy(p2), r), tt, c1, c2, l1, l2) = epg_go(r, tt, c1, tt, l1, l2); +epg_go(tcons(ep_copy(p2), r), ff, c1, c2, l1, l2) = "violation: ext-recon-before-copy"; +# Seal verdict table, disjoint and total over (c1, l1) x (c2, l2): +# stale = copied AND not live; missing = live AND not copied; ok +# otherwise. Stale reports first in mixed cases. +epg_go(tcons(ev_seal, r), n, tt, c2, ff, l2) = "violation: ext-stale-survivor"; +epg_go(tcons(ev_seal, r), n, ff, tt, l1, ff) = "violation: ext-stale-survivor"; +epg_go(tcons(ev_seal, r), n, tt, tt, tt, ff) = "violation: ext-stale-survivor"; +epg_go(tcons(ev_seal, r), n, ff, ff, tt, ff) = "violation: ext-missing"; +epg_go(tcons(ev_seal, r), n, ff, tt, tt, tt) = "violation: ext-missing"; +epg_go(tcons(ev_seal, r), n, ff, ff, tt, tt) = "violation: ext-missing"; +epg_go(tcons(ev_seal, r), n, ff, ff, ff, tt) = "violation: ext-missing"; +epg_go(tcons(ev_seal, r), n, tt, ff, tt, tt) = "violation: ext-missing"; +epg_go(tcons(ev_seal, r), n, ff, ff, ff, ff) = "ok"; +epg_go(tcons(ev_seal, r), n, ff, tt, ff, tt) = "ok"; +epg_go(tcons(ev_seal, r), n, tt, ff, tt, ff) = "ok"; +epg_go(tcons(ev_seal, r), n, tt, tt, tt, tt) = "ok"; +# Pass-throughs: artifact and session machinery is invisible here. +epg_go(tcons(ev_consult(s), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_clear(s), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_replay(s), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_upsert(s), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_delete(s), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_publish(s), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_checkpoint, r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_resume, r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_swrite(k), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_sread_hit(k), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); +epg_go(tcons(ev_sread_miss(k), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, l2); + +# --- Fixtures --- +# green: one honest replacement round on s1, published, quiescent +# checkpoint, seal. Every policy must answer "ok". +∃ trace_green; +trace_green = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_seal, tnil))))))); + +# Each red fixture violates EXACTLY its own policy and satisfies the +# other four (the isolation matrix is asserted by the host). +∃ trace_red_cbr; +trace_red_cbr = tcons(ev_clear(s1), tcons(ev_replay(s1), tnil)); +∃ trace_red_cbu; +trace_red_cbu = tcons(ev_consult(s1), tcons(ev_upsert(s1), tnil)); +∃ trace_red_ops; +trace_red_ops = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_replay(s1), tnil)))); +∃ trace_red_cbp; +trace_red_cbp = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_publish(s1), tcons(ev_seal, tnil))))); +∃ trace_red_seal; +trace_red_seal = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_checkpoint, tcons(ev_seal, tnil))))); + +# Multi-attempt fixtures. green_resume: the B5 idempotent re-copy — a +# crash after attempt 1's replay unit and overlay upsert, an +# un-checkpointed resume that restarts the action from its root and +# re-runs the whole round (re-consult, re-clear, re-copy, re-upsert), +# publishes, checkpoints, seals. Every policy must answer "ok": the +# across-attempt second replay is exactly what once-per-scope's reset +# legalizes. +∃ trace_green_resume; +trace_green_resume = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_resume, tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_seal, tnil)))))))))))); + +# red_ops_resume: a WITHIN-attempt duplicate copy after a resume must +# still violate once-per-scope — the reset is per boundary, not an +# amnesty. Satisfies the other four (no upserts, no seal). +∃ trace_red_ops_resume; +trace_red_ops_resume = tcons(ev_consult(s1), tcons(ev_replay(s1), tcons(ev_resume, tcons(ev_consult(s1), tcons(ev_replay(s1), tcons(ev_replay(s1), tnil)))))); + +# Tombstone fixtures. green_delete: one honest delta round — replay +# the base, overlay upsert, tombstone a departed row, publish the new +# validator, quiescent checkpoint, seal. Every policy answers "ok". +∃ trace_green_delete; +trace_green_delete = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_delete(s1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_seal, tnil)))))))); + +# red_cbu_del: an UN-GROUNDED tombstone — a delete with no clear this +# attempt (the un-regrounded-resume class, delete flavor). Violates +# exactly clear-before-upsert (no replay, no seal, no writes after a +# checkpoint). +∃ trace_red_cbu_del; +trace_red_cbu_del = tcons(ev_consult(s1), tcons(ev_delete(s1), tnil)); + +# red_cbp_del: a delete AFTER the last checkpoint, then seal — deletes +# are progress and dirty the watermark. Grounded (clear precedes), so +# only checkpoint-before-progress fires. +∃ trace_red_cbp_del; +trace_red_cbp_del = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_delete(s1), tcons(ev_seal, tnil))))))); + +# red_seal_del: a scope whose only round activity is a grounded delete +# must still publish before seal — a delete-only delta round that never +# publishes leaves the manifest vouching for a base the artifact no +# longer matches. Violates exactly seal-obligations. +∃ trace_red_seal_del; +trace_red_seal_del = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_delete(s1), tcons(ev_checkpoint, tcons(ev_seal, tnil))))); + +# Session fixtures (policy 6). green_session: an honest round whose +# session write is checkpoint-committed BEFORE the crash — the re-run's +# read hit observes committed state. Every policy answers "ok". +∃ trace_green_session; +trace_green_session = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_swrite(k1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_resume, tcons(ev_sread_hit(k1), tcons(ev_seal, tnil)))))))))); + +# green_session_rollback: the CORRECT crash behavior for an +# UN-checkpointed write — checkpoint-consistent sessions roll it back, +# the re-run's read MISSES, and the at-least-once re-run re-derives +# (the user-stated form: "clearing writes after the last checkpoint, +# on crash — that sounds correct"). Every policy answers "ok"; the +# across-attempt re-copy is B5-legal per once-per-scope's reset. +∃ trace_green_session_rollback; +trace_green_session_rollback = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_swrite(k1), tcons(ev_resume, tcons(ev_sread_miss(k1), tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_seal, tnil)))))))))))))); + +# red_session_zombie: SHIPPED semantics — the session write commits +# durably at op time, the crash rolls the cursor back but not the +# session, and the re-run reads the dead attempt's beyond-checkpoint +# value. Violates exactly session_ckpt_consistency (zombie direction). +∃ trace_red_session_zombie; +trace_red_session_zombie = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_swrite(k1), tcons(ev_resume, tcons(ev_sread_hit(k1), tnil))))))); + +# red_session_amnesia: the REJECTED wholesale resume-clear — a +# checkpoint-committed value is destroyed at the boundary and the +# re-run's read misses data whose producing work will not re-run. +# Violates exactly session_ckpt_consistency (amnesia direction). +∃ trace_red_session_amnesia; +trace_red_session_amnesia = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_swrite(k1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_resume, tcons(ev_sread_miss(k1), tnil))))))))); + +# External-principal fixtures (policy 7). green_ext: the capable-engine +# crash/shrink history — attempt 1 lists {p1, p2}, reconciles (nothing +# stale), copies both, checkpoints; the source shrinks to {p2} across +# the crash; attempt 2 re-lists, reconciliation deletes the dead +# attempt's p1, copies p2, seals. Every policy answers "ok". +∃ trace_green_ext; +trace_green_ext = tcons(ep_list, tcons(ep_live(p1), tcons(ep_live(p2), tcons(ep_recon, tcons(ep_copy(p1), tcons(ep_copy(p2), tcons(ev_checkpoint, tcons(ev_resume, tcons(ep_list, tcons(ep_live(p2), tcons(ep_recon, tcons(ep_copy(p2), tcons(ev_checkpoint, tcons(ev_seal, tnil)))))))))))))); + +# green_ext_carry: the phase COMPLETED before the crash and the +# resumed attempt seals without re-running it — the sealed answer is +# the completed run's answer, legitimately (sync-scoped freshness; the +# sync is not obligated to chase post-completion source changes). +# Every policy answers "ok". +∃ trace_green_ext_carry; +trace_green_ext_carry = tcons(ep_list, tcons(ep_live(p1), tcons(ep_live(p2), tcons(ep_recon, tcons(ep_copy(p1), tcons(ep_copy(p2), tcons(ev_checkpoint, tcons(ev_resume, tcons(ev_seal, tnil))))))))); + +# red_ext_norecon: the warn-and-continue degrade (non-deleting +# engine) — the resumed attempt lists the shrunk answer and copies it +# WITHOUT a completed reconciliation (no ep_recon after its ep_list), +# writing the current answer over the dead attempt's debris. Violates +# exactly external_principal_grounding (recon-before-copy direction). +∃ trace_red_ext_norecon; +trace_red_ext_norecon = tcons(ep_list, tcons(ep_live(p1), tcons(ep_live(p2), tcons(ep_recon, tcons(ep_copy(p1), tcons(ep_copy(p2), tcons(ev_checkpoint, tcons(ev_resume, tcons(ep_list, tcons(ep_live(p2), tcons(ep_copy(p2), tnil))))))))))); + +# red_ext_stale: a dead attempt's copy reaches the seal — the resumed +# attempt lists the shrunk answer but neither reconciles nor copies, +# and p1 (copied by attempt 1, absent from the last list) seals as +# debris. Violates exactly external_principal_grounding +# (stale-survivor direction). +∃ trace_red_ext_stale; +trace_red_ext_stale = tcons(ep_list, tcons(ep_live(p1), tcons(ep_live(p2), tcons(ep_recon, tcons(ep_copy(p1), tcons(ep_copy(p2), tcons(ev_checkpoint, tcons(ev_resume, tcons(ep_list, tcons(ep_live(p2), tcons(ev_seal, tnil))))))))))); diff --git a/formal/occult/tests/probe_axiom_fire.occult b/formal/occult/tests/probe_axiom_fire.occult new file mode 100644 index 000000000..4a19a3a36 --- /dev/null +++ b/formal/occult/tests/probe_axiom_fire.occult @@ -0,0 +1,20 @@ +# Probe: does a single-file axiom (typed universals + free constructors) +# fire as a rewrite under plain CLI evaluation, and does a ground == check +# reduce? Expected: assert -> true, exit 0. If the equation loads +# definitionally instead, app(fresh(7), rows(3)) stays residual and the +# run exits nonzero — that failure routes us to the axiomatic-require +# loading path instead. +# lint:disable mixed-source-semantics +syntax("standard"); + +∃ app; +∃ fresh; +∃ rows; + +x : FoldVal; +e : Epoch; + +app(fresh(e), x) = rows(e); + +assert(cond) = classify cond { {true,} : true, Bool : fail }; +assert(app(fresh(7), rows(3)) == rows(7)); diff --git a/formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json b/formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json new file mode 100644 index 000000000..546bd47f4 --- /dev/null +++ b/formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json @@ -0,0 +1,7 @@ +{ + "version": 2, + "savedAtUtc": "2026-08-31T02:55:14.19044Z", + "sourceSha256": "a0c5d6a8f5445b04e4f5c3c54f58df6774f6fa29a238b7536ebd0c8bb4db0044", + "solverType": "*solve.CompositeSolver", + "payloadB64": "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" +} \ No newline at end of file diff --git a/formal/reviews/graph-spec-round1.md b/formal/reviews/graph-spec-round1.md new file mode 100644 index 000000000..2408fe578 --- /dev/null +++ b/formal/reviews/graph-spec-round1.md @@ -0,0 +1,943 @@ +# Round 1 — adversarial review of GRAPH_MODEL_SPEC v1 (deliverable 4 draft) + +Scope: the entire `formal/GRAPH_MODEL_SPEC.md` v1 DRAFT — ground rules +G-RULE-1..4, machines (§3), the node-execution hot path and supersession +(§4), the durability table (§5), variant axes and mutation toggles (§6), +properties P1–P4 carried plus P5/P6-E/P6-S and the bake-off metrics +(§7), budgets (§8), cells G1–G7 (§9), adequacy obligations (§10), and +the §11 review charge. Baseline anchors: `formal/MODEL_SPEC.md` v11 +FROZEN + MS-CO-001 (conventions, property pins, §9.6 design variants, +durability vocabulary), `formal/GLOSSARY.md` (pinned vocabulary), +`docs/tasks/sync-formal-model-brief.md` (charter, deliverable 4), +`docs/tasks/demand-graph-sync-brief.md` (settled decisions and design +requirements), `formal/walker/CALIBRATION.md` (decisions 19–24, the +6-atomic / 6-overlay / 6-overlay-naive / 6-overlay-last / 3-atomic +hand-off cells). + +Method: mechanical reachability walks of G1 (both crash placements plus +the `suppressionOff` mutant), G2 (all four axis legs plus both kills), +G4 (honest and mutant), G5 (all four sub-cells plus the sweep toggles), +and G7 under the draft's §3–§5 semantics — checking (a) reachability +without hand-placement, (b) that each declared expected verdict derives +from the declared mechanisms and the inherited §7 pins applied by hand, +and (c) that each kill/mutant leg flips for the stated reason; +independent re-derivation of the P1 fold, P2 consult pin, and P3′ +scoping over every walked history; a durability sweep of §5 against +crash/stop placements at each op boundary (two-crash histories +included, per the §8 budget); coherence sweep against MODEL_SPEC §7/§9.6 +pins (complete-rounds replacement counting, empty-fold attestation, +marker-inside-the-unit, clause (iii) suppression, the N4/F6 marker-race +boundary notes) and the glossary; charter-coverage check of deliverable +4's obligations against the §9 cell set. Vocabulary checked against the +glossary term by term. This review does NOT relitigate: P as the +language, the walker model's frozen verdicts, unit-mode +materialization's superiority over the naive/last placements (settled +by cells 6-atomic/6-overlay/6-overlay-naive/6-overlay-last), or the +demand-graph brief's settled decisions. Findings against the unit-mode +HAND-OFF below are findings about the graph-side adaptation of the +settled discipline, not about the walker verdicts. + +Verdict: **REJECT — 11 majors + 7 minors + 3 notes. F1 +re-review-required: its repair introduces new suppression/adoption +semantics that must come back for a targeted round 2 together with the +F2/F3 pins it interlocks with. All other findings are +fix-without-re-review.** No checker verdict from this model is citable +until the round-2 disposition. The draft's skeleton is sound — the +machine decomposition, the axis structure, the inherited discipline +(expected-verdicts-before-first-run, kill obligations, announce-only +monitors) all carry over correctly, and most cells walk. The majors +concentrate in exactly the seam the draft claims as its purpose: what +happens to walker-pinned machinery (the unit marker, the P1 counting +pins, P4's fingerprint) when generations, death, and a frontier +scheduler are placed under it. + +## Findings + +- **F1 (MAJOR, re-review-required) — the unit marker's suppression + scope is per-sync (inherited) but the graph is a generation world; + the collision flips scripted verdicts on G1 and G2 and is never + reconciled.** + - Claim under attack: §4's consult step ("suppressed if the unit + marker for this output key exists this sync"), adopted verbatim + from V-ATOMIC clause (iii); G1's "Expected GREEN on E and S … a + committed attempt-1 unit is superseded per §4"; G2's E+B and S + legs ("H's re-publish retracts G; G re-runs", "G's output + observably stale at seal → G re-run"). + - Evidence, walked. (i) G1, crash-after-unit-commit placement + (reachable in G1's config: crash placement is armed injection, + §1/§2; the scripted before-commit placement is one choice among + several): the unit commits {rows, entry V1, marker} durably; the + checkpoint predates it; resume finds S1 pending → G-RULE-3 bumps + to g2 and marks g1 DEAD; (n, g2) consults, the marker exists this + sync → suppressed; the seal contains g1's rows. Under variant S + those rows carry stamp {S1: g1} with g1 dead → P6-S as written + ("no sealed output carries a stamp containing a dead generation") + fires RED on the leg declared GREEN. The walker's 6-atomic sealed + the identical content green because the walker has no death + concept; the graph's death semantics condemn the exact content + the marker exists to keep. (ii) The same suppression defeats + variant E's retraction: in G2's E+B leg, G@g1's unit committed a + marker for G's output key; H's re-publish retracts G; G's forced + re-execution (n_G, g2) consults, finds the marker → suppressed → + never re-derives → the sealed artifact keeps the d1-embedding + rows → P6-E RED on the leg declared GREEN. Identically for the + S legs: the seal-time observation demands G re-run, the marker + refuses the re-derivation, and the staleness cannot be cleared + before seal. (iii) A marker-suppressed re-execution announces + NOTHING, so its demand (spawn tokens, session ops) is never + re-derived by a live generation — the closure and starvation + consequences are taken up in F7. + - Why it matters: this is the exact hazard the review charge was + told to hunt ("what does 'this sync' mean across generations?"). + The draft adopts unit-mode as settled — correctly — but the + settled pins were proven in a model with at-least-once redo and + NO death/retraction machinery. Marker suppression and generation + death now issue contradictory instructions on the same state + ("do not re-derive" vs "this content's producer is dead; + re-derive or sweep"), and three of the four G2 green legs plus + G1's committed-unit leg are underivable as written. + - Disposition (re-review-required): the repair must pick and pin a + reconciliation — candidates: (a) generation-adoption: a + marker-suppressed re-execution ADOPTS the marked unit's outputs + as its own (stamps rewritten to the live generation, emissions + re-announced from the store), making the dead round's content + live; or (b) generation-scoped markers: the marker suppresses + only within its producing generation's lifetime, and retraction/ + death clears it (at-least-once redo cost returns); or (c) death + redefinition: a generation whose prescribed work fully committed + is not marked dead by a restart (completion inferred from the + marker at resume). Each candidate changes §3/§4/§5 semantics and + the P5/P6 monitors' evidence base; each interacts with F2, F3, + and F7. This is new mechanism, not a wording pin — it requires a + targeted round-2 spot review before any G1/G2/G5d verdict is + citable. + +- **F2 (MAJOR) — the P6 property vocabulary is incomplete and + mechanism-referential: the E+A leg of G2 has no declared property + that can fire, P6-S reads the same stamps the mechanism computes + (so `stampMergeOff` cannot flip), and the S-variant's seal-time + observation step exists in no machine.** + - Claim under attack: G2's "E+A RED (P6-E has no edge to see … + the model exhibits the miss)"; §6's kill row "`stampMergeOff` … + kill cell G2-S"; §7 P6-S; §3's seal sequence ("seal when the + frontier drains: run the SWEEP … then `eSeal`"). + - Evidence: (i) §7 carries P1/P2/P3′/P4 and adds P5/P6-E/P6-S. The + walker's P6-A (ghost session stamps, final-derived-value form) is + NOT carried. P6-E is declared for "variant E + session B" + explicitly. So in the E+A leg no declared monitor can alarm: the + expected RED has no property attached — an implementer building + only the declared monitors seals E+A green and the headline + bake-off fact ("S makes the shipped session store safe; E + requires the session rework") loses its degenerate-leg exhibit. + (ii) `stampMergeOff` removes the read-side stamp merge. P6-S's + evidence IS the stamps: with the merge off, G's rows carry only + {G: g_live}, no dead generation appears in any sealed stamp, the + consistent-cut clause compares only comparable same-node + generations — P6-S is GREEN and the kill cannot flip. A monitor + that reads the mechanism's own bookkeeping cannot detect the + mechanism's mutation; this is a mutation-adequacy failure baked + into the property's definition, and §10.1 says exactly this + halts any recommendation. (iii) P6-S additionally alarms on + same-value re-derivation (H re-derives an identical d1; G's + rows carry the dead g1 stamp; clause 1 fires) — the walker + pinned d1→d2→d1 as non-alarming for P6-A, and P6-E carries the + counterfactual ghost discipline, but P6-S is value-blind with no + stated decision on whether that red is intended (forced-redo + conformance) or a false alarm. (iv) The mechanism half of the S + story — "observably stale at seal → G re-run" — is scheduler + machinery, and §3's dispatch loop has no observation step in the + seal sequence: as declared, seal is drain → sweep → `eSeal`, and + nothing re-runs anybody. Two honest readers diverge on every + S-leg verdict of G2. + - Why it matters: G2 is the calibration case the charter names + (case 2, session laundering) and the bake-off's headline cell; + as drafted its four legs rest on an unnamed property, an + unkillable kill, and an undeclared scheduler step. + - Disposition (fix-without-re-review, interlocks with F1): carry + the walker's P6-A ghost discipline forward as the LAUNDERING + ORACLE for all four legs — ghost dependency labels on emissions + (which session value, which writer generation, value identity), + violation = a sealed output embedding a value that differs from + the key's final live derived value — re-grounded on generations. + Demote lineage edges (E) and stamps (S) to MECHANISM whose job + is to make the oracle green; then `stampMergeOff` and + `retractionOff` both flip against the oracle, not against + themselves. Declare the S-variant's observation-driven re-run + rule in §3 (demand-derivation, session-read, and pre-seal + observation points as scheduler transitions), and pin the + value-blindness decision for P6-S's clause 1. + +- **F3 (MAJOR) — the walker P1 pins do not transfer ungrounded: + fold membership of a DEAD generation's complete round is unpinned + (two readings diverge on G1's committed-unit leg via the + empty-fold attestation pin), and G1's "superseded per §4" claim + is false for unit rounds (marker suppression preempts supersession + — supersession is unreachable for unit-mode keys).** + - Claim under attack: §7 "P1 binding integrity … all v11 pins, + carried unchanged in form … re-grounded on executions"; G1's + "a committed attempt-1 unit is superseded per §4". + - Evidence: take F1's history (unit commits, crash, generation + bump, marker-suppressed re-execution, seal). The only round in + S1's log belongs to the DEAD generation g1. Reading A ("fold + over complete rounds" quantifies over all executions' rounds): + the dead round folds replacement(e1), content matches, entry V1 + attests e1 — green, the 6-atomic analog. Reading B (the fold + quantifies over LIVE generations' rounds — the natural companion + to P5's "announced emissions of LIVE generations only"): the + complete-round set is EMPTY, the fold is the empty partition, + the sealed partition is non-empty → P1-CONTENT red, AND entry V1 + sits over an empty fold → the inherited v11 attestation- + over-empty-fold pin (round-7 F3, CALIBRATION decision 20) fires + outright. Both readings are honest; they diverge on a scripted + cell's verdict — the round-5 F1 / round-7 F3 divergence class + exactly. Separately: for unit-mode keys, dead rows durable ⟺ + the unit committed ⟺ the marker committed ⟺ the re-execution is + suppressed — so §4 supersession (a live commit replacing dead + rows) can NEVER fire for a unit round; G1's cell text attributes + its green to a mechanism that is unreachable in its own config. + Supersession's actual domain is the per-page record path (F6). + - Why it matters: replacement counting and empty-fold attestation + are the two v11 monitor pins the walker's freeze sweep + calibrated (decisions 19–20); importing them "unchanged in + form" into a world where complete rounds can belong to dead + executions leaves the flagship confirmation cell underivable. + - Disposition (fix-without-re-review, contingent on F1's repair): + pin fold membership and replacement-count legality with + generation grounding — recommended: a dead generation's + COMPLETE round remains in the fold and the count until + superseded (its content is what the artifact factually + contains; supersession removes both the rows and the round's + fold/count contribution), which keeps the marker-suppressed + seal green under adoption-style F1 repairs and keeps G1's + mutant-leg legality alarm intact; and correct G1's cell text + (marker suppression, not supersession, is the committed-unit + mechanism). Re-derive G1/G5 verdicts under the chosen pin. + +- **F4 (MAJOR) — generation bookkeeping is unsound across two + crashes: the bump-at-resume rule derives the new generation from + the restored checkpoint alone, so an un-checkpointed resume REUSES + a generation id and the dead set mis-derives — dead debris is + laundered as live.** + - Claim under attack: §5's generation-table row ("the LATEST + generation per pending node is in the frontier checkpoint; the + dead set is derivable (every generation below latest is dead); + no separate durable row"); §3's resume rule; G-RULE-3. + - Evidence, walked within the §8 budget (≤ 2 crashes): checkpoint + cp1 captures S1 pending @ g1. Crash 1 → resume bumps to g2 + (in-memory). Attempt 2 as (S1, g2) commits durable output — + record-path pages, or a session publish stamped {S1: g2} under + variant S. Crash 2 lands before any post-resume checkpoint + (checkpoint-or-skip is a genuine choice point). Resume 2 + restores cp1 AGAIN: latest = g1 → bumps to g2 — the SAME id. + Attempt 3's execution (S1, g2)′ is a different execution with + the same identity; attempt 2's g2-stamped durable debris is now + indistinguishable from attempt 3's live output; "every + generation below latest is dead" classifies attempt-2's debris + as LIVE. G-RULE-3's "an output's producing generation is + stamped at emission time and never reassigned" is violated in + effect (one stamp, two producers), P6-S cannot see the dead + debris (its generation reads as live), and E's supersession + cannot fire on it (no dead rows for the key). Whether §3's + "checkpoint placement is a choice point AS IN THE WALKER" + silently imports the walker's forced Init-checkpoint is exactly + the kind of unstated inheritance §2 forbids relying on — and + even a forced resume checkpoint only closes the hole if it is + pinned to commit BEFORE any resumed execution's first durable + emission. + - Why it matters: every death-keyed mechanism in the spec — the + dead set, purge, supersession, stamp validation, P5's live-only + closure — keys off generation identity; a reusable identity is + a silent-corruption channel of the class the calibration + protocol exists to catch, and it would be hardcoded away by any + encoding that happens to checkpoint eagerly. + - Disposition (fix-without-re-review): pin a forced resume + checkpoint that commits the bumped generation table before the + resumed attempt dispatches anything (ordering stated + explicitly), or make the bump derive from max(restored latest, + highest generation observed in durable stamps/store for the + node) + 1 with the scan rule declared. Add the two-crash + generation-reuse history as a required probe (expected + unreachable after the pin) — the §11 question 2 obligation made + executable. + +- **F5 (MAJOR) — variant E's lineage state does not survive the + crash seam as declared: admitted-by edges are in no durable row + (the purge is unimplementable post-restore), the support + rebuild-agreement check has no well-defined target when the crash + lost announcements the store already reflects, the scripted G5 + family cannot reach a state where the purge does anything, and + therefore the `purgeOff` kill cannot flip.** + - Claim under attack: G-RULE-4 and §5 (checkpoint contents: + pending nodes, completed-derivation set, closed-cut facts, + session index — no spawn/admitted-by edges); §5's + rebuild-agreement row ("rebuilt on resume … the rebuild + agreement check is a monitor obligation"); §3's resume ("Variant + E additionally purges the dead generation's spawn-subtree from + the frontier"); §6's kill row "`purgeOff` … kill cell G5-E crash + window"; G5d's E-leg ("E: purge + no re-demand → swept, GREEN"). + - Evidence: (i) the purge needs, post-restore, the admitted-by + edge (WITH the admitting generation) for every pending node; the + declared checkpoint carries none. G-RULE-4's own rule says + "state the checkpoint does not carry is a FINDING about the + variant" — this review so finds: E requires generation-qualified + admitted-by edges in the durable checkpoint, which is durable + state the mechanism tally must then count (F19). (ii) The + rebuild-agreement check's declared target is "the pre-crash + value"; in the standard window (unit commits, announce processed, + demand derived, THEN crash — no checkpoint between) the restored + frontier predates the derivations the pre-crash support included, + so rebuild ≠ pre-crash value on legal histories and the check + false-alarms; the only implementable target is the + checkpoint-consistent value, which must be said. (iii) + Reachability: for S1's unit-mode single-commit rounds, demand + derivation (C's admission) and S1's completion enter scheduler + state from the SAME announce, so no checkpoint can hold + C-pending ∧ S1-pending; either the checkpoint predates the + announce (C absent from the restored frontier — the purge has + nothing to purge; the SWEEP alone produces G5d's E-leg green) or + it postdates it (S1 completed — no re-execution, no premise). + The purge's real domain is a paginated parent that spawns + mid-round and then restarts — a shape no §9 cell scripts. (iv) + Consequently `purgeOff` cannot flip in the tabled kill cell: in + every reachable G5 history the honest sweep independently drops + the dead-admitted partition, so the mutant leg seals the same + artifact and stays green — a tabled kill that cannot fire, which + §10.1 makes a recommendation-halting defect. + - Why it matters: E's entire mechanism story (purge + derived + support + retraction) is one of the two bake-off contestants; + as drafted its crash behavior is unimplementable from declared + durable state, unprobed by any reachable cell, and its + signature toggle is unkillable — the bake-off would compare S + against an E whose machinery never ran under fire. + - Disposition (fix-without-re-review): add generation-qualified + admitted-by edges to G-RULE-4/§5 (and to the frozen mechanism + tally); pin the rebuild-agreement target as + checkpoint-consistent; re-script the G5-E crash window (and the + `purgeOff` kill) on a paginated record-path parent whose child + admission IS checkpointed while the parent remains pending — + that premise makes the purge load-bearing (with `purgeOff`, the + stale child executes and its redo/closure effects are + observable) — and decide/declare whether the purge also kills + COMPLETED descendants or only pending ones (the two readings + give different redo counts and different G6 outcomes; see F9). + Also correct G5's premise wording — C is fetch-fresh in a + first-sync config and commits a record round, not a "unit". + +- **F6 (MAJOR) — supersession (§4) is not total: the two-live- + derivations-one-output-key interaction that G-RULE-2 explicitly + legalizes is undefined (and alarms P1 legality on legal behavior), + the overlay-intent record path composes dead debris with live rows + (the "structural under E" claim is false to the declared + mechanisms), G4's no-residual-job expectation overreaches, and + G5b's probe is not the strongest premise — with no dedicated + supersession cell anywhere.** + - Claim under attack: G-RULE-2's parenthetical ("two distinct + derivations targeting one output key must both run; their store + interaction is supersession, §4"); §4's supersession definition + ("when execution (n, g′) commits … and a DEAD generation's rows + for K already sit in the current partition, the commit REPLACES + them … under variant E the sweep plus supersession make it + structural"); G4's declared expectation ("NO residual job"); + §1's "fresh-artifact supersession" modeling claim. + - Evidence: (i) §4 defines replacement only against a DEAD + generation's rows. Two distinct derivation hashes with one + output key are both LIVE; G-RULE-2 sends the reader to §4, + which is silent. Compose (union — the partition invariant's + double-stamp poison shape, per the demand-graph brief's silent + partition-poisoning warning) or last-commit-wins (silent loss of + a live derivation's output)? Two honest implementations diverge + — and both commit two complete unit rounds with two copies for + one scope in one sync, so the inherited P1 legality rule alarms + on behavior the spec declares legal. (ii) The 2-worker marker + race (walker N4/round-7 F6, carried over by §4's own boundary + citation) makes this reachable with suppression ON: the two + nodes' consults both pass the absent-marker check and both + commit units. G4's declared expectation — scope locks have NO + residual job — is therefore overreached: it holds for same-hash + duplicates (suppression) but is refuted by the same-key + distinct-hash shape, which no cell scripts. (iii) Record path: + "clear only on REPLACES semantics" means an OVERLAY-intent + fetch-fresh re-run commits over a dead generation's partial + record debris without clearing — dead rows compose with live + rows in one partition, falsifying §4's "never compose … + structural" claim for E. The composition IS detected (the + inherited fresh-replaces fold makes it a P1-CONTENT alarm when + epochs differ — verified by hand), but detected-by-alarm is + precisely not "structural", and when upstream does NOT move + between the attempts the debris is content-identical and the + claim is untested vacuously. Under S the same history is caught + only by P6-S's dead-stamp clause — same-node generations are + causally COMPARABLE, so the consistent-cut clause passes it; + one more reason F2's oracle grounding matters. (iv) G5b probes + only sweep-OFF-with-no-re-demand; the §11 question 5 asks + whether that is the strongest premise — it is not: the + overlay-intent re-demand history above defeats BOTH mechanisms + with the sweep ON. + - Why it matters: supersession is the graph's replacement for the + walker's replay-blocked/supersede machinery and one third of + the three-invariant framing's consume story; an interaction + matrix with undefined and self-contradicting rows would be + silently resolved by whatever the encoding happens to do. + - Disposition (fix-without-re-review): define the supersession + matrix totally over {dead vs live} × {unit vs record} × + {REPLACES vs OVERLAY intent} in §4, including the two-live- + derivations-one-key rule (recommendation: make same-key + distinct-derivation admission a declared connector-contract + violation surfaced as poison, per the partition invariant, OR + pin last-commit-wins with a legality exemption — either way the + P1 counting pin must be updated in the same edit, F3); add a + dedicated supersession cell family: (a) record-path dead-debris + re-run under both intents (expected: REPLACES green, + OVERLAY-intent alarm — the §4 claim corrected to + "detected, not structural"), (b) the same-key distinct-hash + 2-worker race; retitle G4's expectation accordingly. + +- **F7 (MAJOR) — P3′ is cited under the walker pin name but + described as the full walk-equivalence property the walker + explicitly did not build; under the implementable reading, demand + starvation seals green under EVERY declared property — the P5 + ghost closure is circular (monitor and scheduler consume the same + announce stream), no property owns demand-closure completeness, + and no toggle kills under-admission.** + - Claim under attack: §7's "P3′ smear-equivalence (complete + crash-free walk equivalence)"; P5's ghost-closure definition + ("computed by the monitor from announced emissions of LIVE + generations only"); §6's kill table (no under-admission mutant); + the absence of any 5b-style scripted seal-content oracle. + - Evidence: (i) MODEL_SPEC's P3′ is per-scope epoch coherence, + doubly scoped — the full "equal to some crash-free walk" + quantifier was deliberately left as future work because it is an + ∃-over-walks obligation a P monitor cannot discharge. The draft + reuses the name with the stronger description; an implementer + building the walker form checks something materially weaker than + the words. (ii) Under the walker form, walk the starvation + history: S1's spawn announce is processed, C is admitted but no + checkpoint captures it; crash; resume re-runs S1, whose + re-execution is marker-suppressed (F1) and announces nothing; C + is never re-demanded; C never runs. Seal: P1 green for C (no + round, no partition, no entry — empty equals empty), P2 green + (quantifies over rows present), P3′-as-walker green (no manifest + scope), P5 green — the monitor's ghost closure, built from the + same live announces the scheduler consumed, ALSO excludes C. + The artifact silently lost a subtree and every monitor agrees. + P5 as declared can catch a sweep that disobeys the closure, but + never a closure that is wrong — the oracle validates the + scheduler against itself. (iii) Generation death itself is not + an announce event; the monitors' "LIVE generations only" and + "dead generation" predicates are implementable only via an + inference rule (any announce from (n, g′) kills all (n, g < g′)) + that the spec never states — and F1's suppressed restarts emit + no announce, so even the inference goes blind exactly where it + is needed. (iv) The kill table's coverage is asymmetric: + `suppressionOff` kills over-execution, nothing kills + under-admission (a demand-derivation rule that drops tokens), + so §10.2's reachability discipline has no mutation-side + counterpart for the graph's single most load-bearing new + mechanism. + - Why it matters: the walker's 5b taught this exact lesson — a + silent dropout green under every property, whose only executable + oracle was the scripted seal-state expectation — and the graph + spec inherited the lesson's vocabulary but not its oracle. + - Disposition (fix-without-re-review): pin P3′'s actual checkable + form (the walker form, honestly named, with the full-equivalence + form recorded as not built); give P5's ghost closure an + independent evidence base — the MEnv/MUpstream-side + counterfactual closure (which children an honest uninterrupted + walk at the scripted epochs would demand — computable per the + P6-R counterfactual precedent, since policies are deterministic + and content tables are scripted) — or, minimally, a scripted + `SealExpect` oracle per cell in the 5b style; state the + death-inference rule; add a `demandDropOff` (or equivalent + under-admission) mutant with a kill cell. + +- **F8 (MAJOR) — the cross-variant P3′ claim in G5d is not + well-defined as a checker-checkable property: it compares sealed + artifacts ACROSS two runs (two scheduler modes), which no single- + run P monitor can express, and as a general claim it is false- + by-design under smear (the variants may legally seal different, + both-P3′-equivalent artifacts).** + - Claim under attack: G5d's "Both legs must converge to the SAME + sealed artifact (P3′ smear-equivalence across variants — the + strongest cross-variant claim; declare it and let the checker + try to break it)"; §10.6. + - Evidence: the lineage axis is a per-run configuration; a P + monitor observes one run. "E's seal equals S's seal" quantifies + over pairs of runs from different configs — there is no monitor + to fire, so "let the checker try to break it" has no executable + meaning, and §10.6's "if it fails" has no failure event. Deeper: + P3′-equivalence is membership in a SET of legal artifacts + (smear admits many); two correct variants may select different + members whenever their redo behavior differs — which is the + bake-off's own premise (S re-runs what observation finds stale; + E purges and re-derives). In G5d's tight config the legal set + is plausibly a singleton and the claim holds trivially; in any + config where it is not, the claim is false without either + variant being wrong. The strongest cross-variant statement the + charter needs is: each leg satisfies P3′ per-run, and the + enumerated seal-artifact SETS (a meta-comparison over the two + runs' reachable seals, produced by the harness, not a monitor) + either coincide or the recommendation states which artifact is + right — which is what §10.6 already gropes toward. + - Why it matters: the strongest declared cross-variant claim in + the spec is currently unfalsifiable, the precise pathology + ("a badly built model passes its checker") the charter's + execution notes warn against. + - Disposition (fix-without-re-review): reformulate G5d as (a) + per-leg P3′ monitors as usual, plus (b) a harness-level + artifact-set comparison recorded in the bake-off table, with + the divergence rule of §10.6 attached to (b) and honestly + labeled a meta-analysis, not a property. + +- **F9 (MAJOR) — the G6 bake-off scripts cannot distinguish the + variants: both scripted interruptions land where E and S redo + identical work by construction, the §8 envelope contains no + history where purge-vs-stamps can diverge (no depth, no fan-in), + and variant S's refusal rule is operationally unpinned, so the + redo metric is ill-defined — the arbitration deliverable fails as + scripted.** + - Claim under attack: G6's two scripts (stop after S1's unit + before S2 executes; crash during S2's execution) and its + declared falsifiable expectation ("E re-executes MORE under + deep spawn trees"); §8's envelope; §3's variant-S resume rule + ("re-derived or refused at the demand-derivation observation + point"); §11 questions 6 and 10. + - Evidence: (i) the crash script interrupts S2 — a LEAF. Purge of + a leaf's spawn-subtree purges nothing; S re-observes nothing + (no descendants carry S2's dead generation). Both variants + re-execute exactly S2 once. The stop script interrupts before + S2 ever runs — the forced checkpoint is current and total, and + resume re-executes S2 once on both variants. Neither script + produces a between-variants delta; the declared expectation is + not merely undecided but UNDECIDABLE by these cells, and a + bake-off table built from them would report a tie manufactured + by script choice — the fairness failure mode of §11 Q6, in the + opposite direction from the one the question anticipates. (ii) + The divergence cases need a parent restarting OVER completed + descendants (purge discards C's completed work vs stamps keep + or force-redo it) and support fan-in (a child demanded by two + parents; a row supported twice — the refcount and transitive- + retraction machinery of E, and the invalidate-everything + degeneration the session brief worries about, never execute in + a 1-child, depth-1, no-fan-in envelope). §8 has no such + configuration; Q10's answer is therefore NO for the bake-off + cells (the envelope is adequate for the safety cells G1–G5). + (iii) Whether E's purge discards completed descendants (F5's + open reading) and when S "refuses" a dead-admitted pending node + (before or after it executes — the draft's "re-derived or + refused" names no rule and no timing) each swing the + executions-per-node metric; a metric that depends on unpinned + scheduler choices cannot arbitrate anything. + - Why it matters: the charter says this model exists to arbitrate + edges-vs-stamps BY CHECKER OUTPUT; G6 is the redo-work axis of + that arbitration. + - Disposition (fix-without-re-review): add the divergence scripts + — (a) crash while a mid-tree parent with ≥ 1 completed, + checkpointed descendant restarts, identical re-derivation; (b) + the same with a changed re-derivation; (c) a fan-in config (one + child demanded by two live parents; one session publish read by + two readers) — and add the needed envelope rows (depth 2, one + fan-in edge) as an explicit, justified widening of the + inductive bet; pin S's refusal timing and E's purge domain + (F5) first; keep the current two scripts as the + control (expected delta ≈ 0, now an honest calibration point + rather than the whole axis). + +- **F10 (MAJOR) — the stampCompression admissibility obligation has + no cell: the axis is declared in §6, the safety-unchanged claim is + stated in §7, §10 hangs a refutation condition on it — and no §9 + cell declares the axis, exercises `bucketed`, or could refute the + claim; every §9 cell also violates §6's "every cell declares all + three" rule outright.** + - Claim under attack: §6's axis table and its preamble; §7 P6-S's + "Under `stampCompression = bucketed` the SAFETY claim must hold + unchanged and only REDO WORK may grow … a cell where compression + changes any sealed content refutes the admissibility claim"; + §9's cell set. + - Evidence: verified by exhaustive read — G1 through G7 nowhere + mention stampCompression; no cell declares a value for it (nor, + for that matter, for the session axis outside G2 — see F21); + §10.1 covers toggles, and stampCompression is an axis, so it + escapes the kill table too. The admissibility of lossy + compression is not a nicety: it is the charter's stated reason + variant S's mechanism cost is bounded ("error direction is + redone work, never wrong data") and therefore a load-bearing + input to the bake-off's mechanism-count and redo axes. An + unexercised admissibility claim would enter the recommendation + as prose — exactly what §10.5 forbids. + - Why it matters: missing kill/coverage obligation for + load-bearing new machinery, per the severity definition. + - Disposition (fix-without-re-review): add the compression cell + family — re-run G2's S legs and the G5 family under + `stampCompression = bucketed`, expected: every safety verdict + unchanged, redo count recorded (growth permitted and expected — + bucketing makes unrelated nodes' deaths look observable); the + refutation condition of §7 becomes those cells' declared + mismatch criterion. State in §6 which axis values every §9 cell + runs by default. + +- **F11 (MAJOR) — the P4 tranche does not transfer as claimed: + the walker's stuck-detection fingerprint (byte-identical restored + checkpoint state) can NEVER fire under generation bumping, so + G7's stuck leg flips green as written; attempt-failure semantics + for a frontier scheduler are undeclared; and §8 has no attempt + budget for the ladder to consume.** + - Claim under attack: G7's "expected: without an abandon rule the + re-fail loop is P4-STUCK RED (same shape as the walker's)"; §7's + "P4 progress (no stuck re-failure; the walker's ladder analog if + a scenario needs one)"; §8. + - Evidence: the walker's livelock detection (MODEL_SPEC §7 P4, + CALIBRATION decision 17) fires on two consecutive failures from + byte-identical restored checkpoint state. In the graph, every + failure-forced checkpoint captures the failing node at a HIGHER + generation than the last (the bump is the resume rule), so no + two restored states are byte-identical and the detector is + structurally silent — the generation counter is a Zeno counter + under the fingerprint. Reader A (byte-identical, as inherited): + G7's stuck leg seals... never — the monitor simply doesn't fire + and the leg is GREEN, flipping the declared RED. Reader B + (fingerprint modulo generations): RED as declared. Whether a + failure forces a checkpoint at all, and indeed what an "attempt + failure" IS under a frontier scheduler (does one node's loud + failure fail the attempt walker-style, or does the frontier + route around it and the node alone re-fails?), is undeclared in + §3 — the walker's decision-16 machinery has no graph analog in + the draft. And §8's interruption budget ("≤ 2 crashes or 1 stop + per cell") has no attempt-failure/resume-ladder row, while G7 + needs at least three attempts for k = 2 detection. + - Why it matters: G7's whole point is that the P4 findings carry + over "rather than dissolving"; as drafted the detector + dissolves and the cell cannot show it. + - Disposition (fix-without-re-review): pin the stuck fingerprint + as generation-blind (failure point, reason, restored state + modulo the generation table); declare attempt-failure semantics + for MGraphScheduler (recommended: node-loud-failure fails the + attempt, walker-parity, so the ladder analog is meaningful); + add the attempt-budget row (≤ 3 attempts, walker parity). + +- **F12 (MINOR) — demand-derivation timing is unpinned.** §3's + dispatch loop reads batch-shaped ("collect its announced + emissions, derive demand") while §4 announces emissions at commit; + whether the scheduler derives demand per-announce (incrementally, + atomic with completion bookkeeping) or after execution completion + determines which checkpoint contents are reachable — F5(iii)'s + walk turned on it. One sentence pins it (recommended: + per-announce, atomic with the announce's completion effects, which + is what makes the F5 reachability analysis stable). + Fix-without-re-review. + +- **F13 (MINOR) — "completed-derivation set" is admission-keyed in + G-RULE-2 but completion-named everywhere else, and the resume-side + completed-vs-never-admitted distinction is never stated.** G-RULE-2 + suppresses on "already ADMITTED this sync"; §3/G-RULE-4 call the + same state the "completed-derivation set". A resume must + distinguish a node absent-from-pending-because-completed from + never-admitted, presumably via admitted ∧ ¬pending — but that rule + is nowhere written, and it is load-bearing for every restart walk + in this review. Rename to admitted-derivation set (or split the + two sets) and state the resume rule. Fix-without-re-review. + +- **F14 (MINOR) — record-path clearing and the intent enum arrive in + a parenthesis, not a declaration.** §4's "(shipped record path; + clear only on REPLACES semantics)" quietly imports the deliverable-3 + wire-intent enum as BUILT graph semantics and adds a record-path + clear the walker's §4 never had, without §3 op-vocabulary + registration (which §5's crash protocol and the arrival-order choice + points quantify over) and without pinning clear placement + (first page of the round only, presumably). This is the round-6 / + MS-CO-001 registration lesson verbatim. Register the ops and + intents in §3, pin clear placement, cross-reference from §4. + Fix-without-re-review. + +- **F15 (MINOR) — the aggregate node X exists in the budget and in + no cell.** §1 promises X "executes only in configurations where + its precondition is scripted true"; §8 budgets it; no §9 cell + contains such a configuration, so the promise is about an empty + set and Q8's honest-labeling check has nothing to inspect. Either + add the scripted-precondition configuration (X executes last, + P1–P5 checked around it — cheap, and it gives deliverable 5 its + hand-off) or strike X from v1's budget and state the deferral. + Fix-without-re-review. + +- **F16 (MINOR) — cross-sync stamp scoping is undefined for variant + S.** Generations are per-sync restart counters; G1's sync-2 replay + copies rows whose stamps reference sync-1 generations, which the + current sync's generation table cannot classify (ill-typed dead-set + lookups; a refuse-on-unknown reading would false-alarm every warm + replay under S). Pin the rule — recommended: replay re-stamps + copied rows with the replaying execution's stamp (the sealed + source artifact was observation-clean by its own seal), with an + explicit note that cross-sync session-stamp travel remains the + walker P6-R machinery's jurisdiction. Fix-without-re-review. + +- **F17 (MINOR) — the sessions × replay product (the walker's + scenario-7 class) is neither covered nor excluded.** The graph + model replays inside node executions, so replay elision of session + writes is structural here too; the draft's §1 abstraction list is + silent on the product, and silence is how the walker model lost it + the first time (round-6 lesson). Either declare it out of scope + with the argument (taint machinery is verdict-side and orthogonal + to the lineage axis; the walker cells own it) or script the 7a/7b + analogs on the graph runtime. Fix-without-re-review. + +- **F18 (MINOR) — P6-E's retraction-liveness form does not bind the + re-run to the live value.** "Every reader execution that consumed + the dead value must re-run before seal" is satisfied by a re-run + that itself read the stale KV value (reachable in G2's crash + config: G's crash-forced re-run reads d1 from the durable KV + before H re-publishes) — the re-run happened, the sealed output + still embeds d1. The mechanism plausibly closes this (retraction + keyed on the value/key, retracting readers of any dead value on + re-publish), and F2's final-value oracle closes it at the monitor + — but the retraction rule's keying must be pinned so the fan-in + quantification of Q7 is over reader-executions-of-dead-values, + not reader-nodes. Fix-without-re-review, subsumed if F2's oracle + disposition is taken. + +- **F19 (NOTE) — the frozen mechanism tally must absorb this + round's machinery before the cells run.** F5 adds durable + admitted-by edges to E's column; F2 adds the scheduler-side + observation/re-run step to S's column (it was implicitly free); + F6's supersession matrix belongs to the shared column. The tally + is the pre-hoc fairness device — freeze it in the spec revision, + not in the calibration report after the numbers exist. + +- **F20 (NOTE) — the recommendation's decision rule is unpinned.** + §10.5 fixes the table's provenance but not the procedure: what + wins when properties tie, mechanisms differ by definition-sensitive + counts, and redo work splits by script family. Record the + arbitration rule (and where the written recommendation lives — + the CALIBRATION.md analog for `formal/graph/`) before the first + bake-off run, for the same reason the tally is frozen. + +- **F21 (NOTE) — the session axis is vacuous outside G2; say so + once.** Only G2 declares session machinery (H and G exist "scenario + G2 only"), so §6's every-cell-declares-all-three rule is + unsatisfiable as written for the session axis in six of seven + scenarios. One sentence ("cells without session actors run + variant A, axis vacuous") plus F10's default declaration makes §6 + total. + +## Mechanical walks (the §10.2 obligation, executed for this review) + +- **G1.** Crash-before-unit-commit leg: reachable (armed injection at + the pre-commit boundary; nothing durable for S1; resume bumps, + re-consults, revalidation vs epoch 2 fails, fetch-fresh lands + clean); GREEN derives on both variants — confirmed as scripted. + Crash-after-unit-commit placement (same config, different armed + position): verdict underivable — F1 (marker suppresses the live + generation; P6-S fires on the dead stamp under S) and F3 (fold + membership of the dead round; "superseded per §4" false — the + supersession mechanism is unreachable for unit keys). Mutant + (`suppressionOff`): the duplicate-admission race schedule (both + consults pass the absent-marker check before either unit commits — + the inherited N4/F6 window) reaches the double unit; last unit + coherent; legality-only alarm derives as declared; the sequential + schedule is marker-suppressed and green, which is consistent with + a first-find RED. Flip confirmed for the stated reason. +- **G2 (all four legs).** Premise reachable in all legs: H's session + write is a store op committed mid-execution (durable KV), a + nondet checkpoint captures G completed ∧ H pending, crash, H alone + restarts — no hand-placement. E+A: the miss is real, but no + declared property fires — F2; the leg's RED is currently + property-less. E+B: retraction → G re-run is defeated by G's own + unit marker — F1; GREEN underivable as written. `retractionOff` + kill: flips RED via the sealed-d1 witness, PROVIDED the monitor is + grounded per F2 (as drafted the witness form works; confirmed). + S+A and S+B: the merge → dead-stamp → re-run story requires a + seal-time observation step absent from §3 (F2) and the re-run is + marker-suppressed (F1); GREEN underivable as written. + `stampMergeOff` kill: CANNOT flip — the monitor's evidence is the + stamps the mutant removes (F2). The headline bake-off fact + survives IN DIRECTION under the F1+F2 repairs (nothing found + contradicts S-makes-A-safe once the observation step exists and + the marker is generation-aware), but no leg of it is currently + derivable. +- **G4.** Honest leg: root emits S1's token twice in one announce; + second admission suppressed by derivation hash; single unit; + GREEN derives. Mutant: double admission → two workers → both + consults pass the absent-marker window → double unit → P1 + legality alarm; RED derives via the race schedule for the stated + reason (the sequential schedule is suppressed by the first unit's + marker and stays green — worth stating in the cell so the + first-find expectation is explicit). Kill flip confirmed. The + cell's FURTHER claim — no residual job for scope locks — is + refuted by the distinct-derivation same-key shape the cell does + not script: F6. +- **G5a.** Reachable via the checkpoint-predates-S1's-announce + window (F5(iii)): restored frontier holds S1 pending, C absent; C's + committed partition is orphan debris; S1 re-runs at epoch 2, no + child marker; honest sweep drops C's partition (outside the + live-announce closure). GREEN derives on both variants — via the + SWEEP alone; purge contributes nothing in any reachable schedule + (F5). Note C's commit is a record round, not a "unit" (F5 + wording). +- **G5b.** `sweepOff`: C's dead partition seals; P5-UNDER RED + derives on both variants (S additionally alarms P6-S on the dead + stamp — multiple alarms, direction consistent). The E-leg + candidate-hole probe is honest as far as it goes: no re-demand of + K_C means supersession cannot fire and the leg cannot be green. + But it is not the strongest premise — F6(iv)'s overlay-intent + re-demand history defeats sweep and supersession with the sweep + ON. Kill flip confirmed; probe strength finding stands. +- **G5c.** `sweepOverreach`: S2's in-closure partition dropped; + P5-OVER RED and P1-CONTENT (fold has rows the partition lost) + both derive. Confirmed as scripted. +- **G5d.** E-leg premise as scripted (purge removes C from the + restored frontier) is UNREACHABLE — no checkpoint can hold + C-pending ∧ S1-pending for a single-unit parent (F5(iii)); the + green that derives comes from the sweep, so the cell's mechanism + attribution is wrong even though its verdict direction survives. + S-leg: derives as scripted (C's rows carry the dead S1 stamp; + outside the closure; swept) modulo F1's death/announce blindness. + The cross-variant same-artifact claim: not checkable as declared + — F8. +- **G7.** Premise requires attempt-failure machinery (§3 has none — + F11); under the inherited byte-identical fingerprint the stuck + detector never fires across generation-bumped checkpoints, so the + declared RED does not derive (F11). Ladder leg contingent on the + same pins plus the missing attempt-budget row. Direction + plausible after the F11 pins; underivable as written. + +## Answers to the §11 review charge (ten questions) + +1. **G-RULE-1 enforcement**: CLEAN. Every scripted demand source in + G1–G7 is an announced emission (spawn tokens, the child marker + row, session values); mutation timing is env-side state, not + structure; no script routes structure through response-loop + position. Residual: the derivation TIMING ambiguity (F12) is a + §3 gap, not a purity leak. +2. **Generation/death under two crashes**: FINDING — F4 (generation + id reuse from un-checkpointed resumes; dead-set mis-derivation). + The during-checkpoint-commit half is clean (eCheckpoint is one + atomic op; either token wins wholly). +3. **E's derived-support rebuild well-definedness**: FINDING — F5 + (no well-defined target under the announce-lost/store-reflects + gap; admitted-by edges missing from the durable checkpoint + besides). +4. **S stamp durability leaks**: QUALIFIED CLEAN. The §5 row is + internally coherent — no path drops or narrows a stamp while + keeping its output (a lost un-checkpointed spawn token loses the + whole output, which is consistent). The leaks found are + evidentiary, not durability: death is not announce-visible + (F7(iii)) and cross-sync stamps are unscoped (F16). +5. **Supersession sufficiency / two-key interleavings**: FINDING — + F6. The two-live-derivations-one-key row is undefined; the + overlay-intent record path composes dead with live under E with + the sweep on; G5b's probe premise is not the strongest. +6. **G6 script fairness**: FINDING — F9. The scripts do not + pre-decide the bake-off; worse, they cannot decide it (identical + redo by construction on both scripted interruptions). +7. **P6-E under fan-in**: the per-reader quantification is correct + as written (one non-re-run reader among two is a witness), but + the form does not bind re-runs to the live value — F18 (and the + envelope contains no fan-in to exercise the question — F9). +8. **Aggregate node honesty**: no vacuous P7 is smuggled (no cell + claims or approaches P7), but the honesty check is vacuous for a + different reason: no configuration containing X exists — F15. +9. **P1 pins transfer**: FINDING — F3. Complete-rounds counting and + the empty-fold attestation pin need generation grounding before + they are well-defined over logs containing dead generations' + rounds; debris-surfaces-through-content does survive supersession + on the record path (verified by hand in F6's walk — the + fresh-replaces fold alarms on dead∪live composition when epochs + differ), which is the one clean transfer in this family. +10. **Small-scope adequacy**: SPLIT. Adequate for the safety cells + (G1–G5, G7 — every walked premise fits the envelope). NOT + adequate for the bake-off: no depth, no fan-in means + purge-vs-support cannot diverge from stamps anywhere in the + envelope, E's refcount/transitive-retraction machinery never + executes, and the session brief's invalidate-everything + degeneration is unreachable — FINDING, folded into F9. + +## Charter-coverage check (deliverable 4 obligations vs the cell set) + +Present and correctly shaped: frontier/suppression/generations/sweep +(G4, G5), both lineage variants as a shared-mechanism axis (per the +charter's "implement both and compare"), session variants A/B, +calibration case 2 re-run (G2), case 1/3/4 premise re-runs (G1, G3, +G4), P5 in both failure directions, redo/mechanism/property as the +declared comparison axes, refutation-is-success framing. Missing or +defective: the stampCompression admissibility cell (F10), a dedicated +fresh-artifact supersession cell family (F6 — §1 lists supersession as +modeled; no cell exercises it, and for unit keys it is unreachable), +bake-off scripts that can discriminate (F9), the recommendation's +decision rule and destination (F20), and the E-variant's durable-state +honesty in the mechanism tally (F19). The "expect the model to force +design decisions" clause is discharged early: F1's marker/generation +reconciliation IS such a forced decision, surfaced by review rather +than by checker — consistent with the charter's purpose, and the +reason the re-review is targeted rather than resented. + +## Verified clean (for the draft's revision record) + +- The no-relitigation boundary is respected: unit-mode is adopted + without rebuilding the naive/last placements, the walker cells are + cited as settled hand-offs exactly as CALIBRATION.md's pending note + designed, and nothing in the draft re-opens P-as-language or the + frozen verdicts. The findings above concern the graph-side + adaptation, not the hand-off itself. +- §2's inheritance is genuine: arrival order, armed crash injection, + truthful validators, announce-only monitors, and + expected-verdicts-before-first-run all carry with correct graph + additions; G-RULE-1's monitor discipline (ghost closure from + announces only) is the right instinct even where F7 shows it needs + an independent evidence base. +- G3 walks clean end to end: stop-forced checkpoint captures S1 at + its consult-granularity cursor, resume bumps the stopped + generation, the re-consult hits the ACTUALLY current (swapped) base + and fails validation → fetch-fresh; the 3-atomic closure carries + over; cheap confirmation cell as declared. +- G5b and G5c derive exactly as scripted; the P5-UNDER/P5-OVER split + with separately named directions is well-formed and both kill + flips are real (modulo nothing — these two work as written). +- The walker→graph mapping table (§5) is accurate: restart-from-root + ↦ generation bump, hit-map ↦ nothing (in-unit marker as consult + provenance, matching the pilots), EnqueuePageTokens ↦ demand-derived + admission, NextPageToken ↦ same-node cursor advance. +- P2's consult pin transfers cleanly: a marker-suppressed seal's + scope was consulted (validation match) by the dead generation + within the same sync, which qualifies under the any-attempt + wording; staleness hops compute correctly on replayed rows. +- Torn rounds are unreachable model-wide (a round is one execution's + ops; executions never span attempt boundaries), and the draft + keeps the monitor active anyway — the inherited discipline applied + correctly, and stronger than the walker (where only unit-mode + scopes had the by-construction guarantee). +- Vocabulary: glossary conformance is exact everywhere it was + checked (node/execution/generation/derivation hash/output key/ + demand closure/sweep/supersession/causal stamp/consistent cut/ + sealed cut; session variant definitions; the three-invariant + framing). The single drift found is "completed-derivation set" + (F13) — a draft-internal term, not a glossary term. +- Budget shape (§8) inherits the envelope honestly and restates the + inductive bet; the G2-only session actors and the scripted-config- + only aggregate node are correctly fenced (their gaps — F15, F21 — + are registration, not smuggling). +- Public-repo hygiene: clean. No customer names, tenant identifiers, + or internal infrastructure anywhere in the draft. + +## Summary + +| finding | severity | one line | disposition | +|---|---|---|---| +| F1 | MAJOR | per-sync unit-marker suppression vs generation death/retraction is unreconciled; flips G1's committed-unit leg and three G2 legs; the imported walker assumption the charge predicted | pick and pin adoption/scoped-marker/death-redefinition semantics; **re-review-required** (targeted round 2) | +| F2 | MAJOR | P6 vocabulary incomplete: G2 E+A red has no property; P6-S is mechanism-referential so `stampMergeOff` cannot flip; S's seal observation step is in no machine | carry P6-A ghost oracle re-grounded on generations; declare observation machinery in §3; fix-without-re-review | +| F3 | MAJOR | P1 fold/count membership of dead generations' complete rounds unpinned (empty-fold pin fires under one honest reading); G1's "superseded per §4" false — supersession unreachable for unit keys | generation-grounded fold/counting pins; correct G1 text; fix-without-re-review | +| F4 | MAJOR | generation ids reused across un-checkpointed resumes (2 crashes); dead set mis-derives; debris laundered live | forced resume checkpoint ordering pin (or durable-max bump rule) + reuse probe; fix-without-re-review | +| F5 | MAJOR | E's lineage state: admitted-by edges in no durable row; rebuild-agreement target ill-defined; purge unreachable in scripted G5; `purgeOff` kill cannot flip | checkpoint-content + tally edit; checkpoint-consistent rebuild target; re-script the crash window on a paginated parent; fix-without-re-review | +| F6 | MAJOR | supersession not total: live-live same-key undefined (P1 alarms on legal behavior); overlay-intent record path composes dead+live (E "structural" claim false); G4 subsumption overreach; G5b not strongest; no supersession cell | total supersession matrix in §4 + dedicated cells; fix-without-re-review | +| F7 | MAJOR | P3′ name/form drift; P5 ghost closure is circular; demand starvation seals green under every property; no under-admission kill | pin P3′'s form; counterfactual closure or SealExpect oracles; death-inference rule; demand-drop mutant; fix-without-re-review | +| F8 | MAJOR | cross-variant P3′ (G5d) is a cross-run comparison no P monitor can check, and over-strong under smear | per-leg P3′ + harness-level artifact-set comparison with the §10.6 divergence rule; fix-without-re-review | +| F9 | MAJOR | G6 scripts cannot differentiate E/S (leaf crash, pre-execution stop); envelope has no depth/fan-in; S's refusal timing unpinned — the arbitration axis is vacuous | divergence scripts + envelope rows + refusal/purge-domain pins; fix-without-re-review | +| F10 | MAJOR | stampCompression admissibility: §7 obligation, §6 axis, no §9 cell, no §10 entry; all cells violate declare-all-three | add bucketed re-runs of G2-S/G5 with recorded redo; default axis declarations; fix-without-re-review | +| F11 | MAJOR | P4 stuck fingerprint never fires under generation bumps (G7 stuck leg flips green); attempt-failure semantics undeclared; no attempt budget | generation-blind fingerprint; declare attempt failure; budget row; fix-without-re-review | +| F12 | MINOR | demand-derivation timing (per-announce vs post-completion) unpinned; checkpoint reachability depends on it | one-sentence pin; fix-without-re-review | +| F13 | MINOR | "completed-derivation set" is admission-keyed; completed-vs-never-admitted resume rule unstated | rename + state the rule; fix-without-re-review | +| F14 | MINOR | record-path clear + intent enum arrive via parenthesis; §3 registration and clear-placement pin missing (MS-CO-001 lesson) | register ops/intents; pin placement; fix-without-re-review | +| F15 | MINOR | aggregate node X budgeted but appears in no configuration; §1's promise ranges over an empty set | add the scripted-precondition config or de-scope X; fix-without-re-review | +| F16 | MINOR | cross-sync stamp scoping undefined (per-sync generations vs replayed rows' stamps) | pin restamp-on-replay (+ P6-R jurisdiction note); fix-without-re-review | +| F17 | MINOR | sessions × replay product neither covered nor excluded in §1 | explicit exclusion with argument, or 7a/7b analog cells; fix-without-re-review | +| F18 | MINOR | P6-E's "re-run before seal" doesn't bind the re-run to the live value (re-run-before-re-publish schedules) | pin retraction keying / adopt F2's final-value oracle; fix-without-re-review | +| F19 | NOTE | mechanism tally must absorb F2/F5/F6 machinery before any bake-off run | freeze the amended tally in the spec revision | +| F20 | NOTE | recommendation decision rule and destination unpinned | record the arbitration procedure pre-run | +| F21 | NOTE | session axis vacuous outside G2; §6's all-three rule unsatisfiable as written | one-sentence default declaration | diff --git a/formal/reviews/graph-spec-round2-adoption.md b/formal/reviews/graph-spec-round2-adoption.md new file mode 100644 index 000000000..42cd36f68 --- /dev/null +++ b/formal/reviews/graph-spec-round2-adoption.md @@ -0,0 +1,743 @@ +# Round 2 (TARGETED) — premise-validated adoption (§4a) and its interlocks, GRAPH_MODEL_SPEC v2 + +Scope: the targeted round-2 spot review the round-1 disposition of F1 +required. PRIMARY: §4a (premise-validated adoption — the marker as +memoization entry, adopt-on-equal-digest / re-derive-on-differing- +digest, `eAdopt` semantics, §4d fold transfer, row re-announcement), +answering v2's §11 round-2 charge questions 1–7 mechanically. +SECONDARY: composition of the F2 (P6-G + observation pass), F3 (§4d), +F6 (§4b matrix incl. poison exemption), and F7 (closure oracle + +`eAnnGenBump`) dispositions WITH §4a — not a re-review of those +dispositions as applied; and the acceptance walks: G1's three legs and +G2's four legs under v2 semantics. Anchors: `formal/MODEL_SPEC.md` v11 +FROZEN + MS-CO-001 (§7 property pins incl. the round-5 F8 consult +qualification and round-7 F2/F3 counting/attestation pins; §9.6 +V-ATOMIC / V-OVERLAY-UNIT), `formal/GLOSSARY.md`, +`formal/walker/CALIBRATION.md` decisions 19–24, +`formal/reviews/graph-spec-round1.md`. Round-1 dispositions v2 applied +as specified are NOT relitigated; only their composition with §4a is +in scope. + +Method: mechanical walks of every §4a branch (adopt, re-derive, and +their interleavings) under 2 workers, ≤ 2 crashes, ≤ 3 attempts, ≤ 3 +epochs, per the §8 budget; independent re-derivation of P1 (§4d +grounding), P2/P3′ qualification, P6-G/P6-E/P6-S, and the closure +oracle over every walked history; a durability sweep of the marker / +`eAdopt` / checkpoint rows of §5 against crash and announce-in-flight +placements (the G-RULE-1 window between a store commit and its +announce processing is load-bearing in several walks below); a +back-port thought experiment of §4d onto the v11 walker cells +(charge question 4); totality sweep of the G8a no-marker pin against +the §4b matrix and every marker state a walk can construct. + +Verdict: **REJECT — 6 majors + 8 minors + 3 notes. R2-F2 +(rows-only adoption strands dead session publishes) is +re-review-required: every candidate repair is new mechanism touching +the F17 exclusion boundary and the §7.5 tally. The other five majors +are fix-without-re-review, spot-checkable in the same targeted round +3 that R2-F2 forces.** The repair's core is sound in direction: G1's +three legs derive (leg (ii) with a mechanism-attribution correction), +G2's four axis legs derive (E+B conditionally on the R2-F1 pin), both +G2 kills flip against P6-G for the stated reasons, and the round-1 +starvation hole (F7(ii)) is genuinely closed for completed children. +The rejection is for what the new mechanism composes into at its +seams: mid-attempt death with in-flight executions, session publishes +under adoption, the digest's lossy canonicalization of failed +revalidations, marker lifecycle on the re-derive-to-record path, and +the admitted-derivation set's behavior after purge/refusal. + +## Majors + +- **R2-F1 (MAJOR) — the fate of an in-flight execution whose + generation dies MID-ATTEMPT is undeclared; under the + run-to-completion reading a dead execution's late unit commit (its + clear constituent included) wipes a live re-derivation's rows, and + variant E seals stale content on a leg declared GREEN.** + - Claim under attack: G2's E+B leg ("P6-G GREEN, P6-E green"); + §4a's adopt/re-derive dichotomy (implicitly assumes the dead + generation's execution is gone); §3's retraction pin and the + retraction queue (§7.5), whose enqueue/drain timing and effect on + in-flight readers are nowhere stated. + - Evidence, walked. §5 declares in-flight execution state volatile + ONLY against crash ("a crash loses the execution"). Mid-attempt + death — a retraction-forced bump (E+B) — has no such clause: + G-RULE-3 gates dispatch of (n, g+1) on (n, g) being DEAD, and + death is declared at the bump, which is scheduler bookkeeping. + Nothing kills, cancels, or fences the dead execution's worker, + and MStore has no death gate (§5 puts the generation table in + MGraphScheduler; §3's op registration carries no liveness + precondition). Budget-legal history, G2 E+B chassis, 2 workers: + H's re-publish lands while reader G@g2 is in flight having read + the prior value (the §3 keying pin itself contemplates exactly + this reader: "re-runs that themselves read a stale value before + the re-publish landed"). The retraction bumps G to g3; G@g3 + dispatches on the free worker, finds the marker, recomputes + premises (reads the live value), re-derives, and commits its + unit. THEN the dead G@g2 — never cancelled — commits ITS unit: + an atomic {clear, rows, marker} whose clear removes g3's live + rows and installs rows embedding the dead session value, with + marker (g2, stale digest). No further re-publish occurs, so no + further retraction fires; variant E's pre-seal condition is only + that the retraction queue is empty (it is — g3 executed); E has + no observation pass. Seal embeds a value differing from the + key's final live derived value → P6-G RED on the leg declared + GREEN. Under S the same schedule is caught (the late unit's rows + carry the dead g2 stamp; the pre-seal pass forces a re-run) — the + asymmetry is itself bake-off-relevant and currently invisible. + Under the kill-on-death reading, none of this is reachable and + the declared green derives. Two honest readings, one scripted + cell verdict — the severity definition verbatim. + - Why it matters: this is the inherited marker-race window the + charge's question 1 named, relocated by the repair. Adoption + removed the double-unit shape for same-generation races; + the dead-vs-live race survives because §4a decides adopt vs + re-derive per execution but never says the dead execution's + store ops stop counting. + - Disposition (fix-without-re-review, verified in the R2-F2 round + 3): pin ONE of — (a) QUIESCE-BEFORE-BUMP: a mid-attempt + generation bump commits only after the dying execution's worker + has quiesced (walker decision-16 precedent; scheduler rule, no + tally change); or (b) a store-side DEATH FENCE: the bump commits + a fence op and MStore refuses ops from fenced generations — + which amends the §7.5 frozen tally (a new shared store rule) and + incidentally closes R2-M2. Add the dead-in-flight interleave as + a probe cell (expected unreachable-after-pin), and state the + retraction queue's enqueue/drain semantics in §3. + +- **R2-F2 (MAJOR, re-review-required) — adoption re-grounds ROWS + ONLY; the dead generation's SESSION PUBLISHES stay stamped with + the dead writer generation, so downstream readers can never clear + the dead component: the S-variant pre-seal pass loses its progress + guarantee (the "finite fixpoint" is budget exhaustion, not + convergence) and seals dead stamps on an honest history, and + P6-E's quantification alarms on the same honest history under E.** + - Claim under attack: §4a ("Adoption re-announces ROWS ONLY, never + session ops"); §3's seal sequence ("iterate to fixpoint; bounded + by the §8 attempt budget times the node count, so the model's + fixpoint is finite by construction"); G2's same-value control + leg; G6a's "expected redo: both ≈ 1"; G6c's "both keep C with + zero redo"; §11 question 5's premise that the bound is the + question. + - Evidence, walked (budget-legal: 1 crash, no mutation, the + G-RULE-1 announce-in-flight checkpoint window). H's unit — H + publishes d1 during its execution (the publish is its own store + op, durable) — commits durably; the completion announce is in + flight; a checkpoint commits capturing H PENDING (announce + arrival order is a §2 choice point, so a scheduler step fits + between commit and processing); crash loses the announce. G + completed earlier, its rows embedding d1 with merged stamp + {G: g_G, H: g1_H} under S. Resume: H pending → bump, g1_H dead. + H@g2 finds its marker; no upstream mutation, H reads no + sessions → digest EQUAL → ADOPT. Adoption re-grounds H's ROWS + under g2 and re-announces them; d1 remains writer-stamped g1_H — + a DEAD OUTPUT by the glossary's own definition, content-final + but generation-dead, and nothing ever re-grounds it. Now walk + the pre-seal pass (S legs): G's rows carry {H: g1_H} dead → the + pass forces a re-run of the PRODUCING node, G. G's re-execution + finds G's marker; its session re-read returns d1 with identity + AND writer stamp unchanged (g1_H) → digest EQUAL → ADOPT — and + `eAdopt` substitutes only G's OWN from/to generations in the + row stamps; the H-component persists. The pass observes the same + dead stamp, forces G again, G adopts again: NO PROGRESS PER + ITERATION. Re-derivation does not help either — a re-derived G + merges the re-read value's stamp, {H: g1_H}, back in. The + iteration terminates only at the stated bound, and the sealed + rows carry a dead generation → P6-S RED on an honest, no-mutant, + no-mutation history. Under E+B the same placement alarms the + conformance monitor directly: G is a "reader execution of a dead + value" (d1 became dead at H's bump) and nothing re-runs it + (retraction fires only on re-publish; adoption never + re-publishes) → P6-E RED honest. P6-G stays green (content is + final) — these are mechanism-conformance reds on honest legs, + which §10.1's discipline cannot distinguish from real + mutation-adequacy failures. Ripple: G6a's ≈ 1 and G6c's + zero-redo expectations hold only in schedules where the + checkpoint captured the writer's completion; the + announce-in-flight placement makes them placement-dependent. + Note also G-RULE-1 lists SESSION PUBLISHES as demand sources; + adoption's rows-only re-announce therefore also fails to + re-derive publish-derived demand — no scripted cell demands via + a publish, so this facet is latent, but the asymmetry is real. + - Why it matters: this is charge questions 2 and 5 jointly — a + verdict input (the writer-generation liveness of embedded + session values) that adoption changes the truth of but cannot + repair, and a fixpoint claim that is false as a convergence + claim exactly where adoption and sessions meet. It sits directly + on the F17 exclusion boundary ("re-announces ROWS, never session + ops" is §1's exclusion argument made load-bearing). + - Disposition (RE-REVIEW-REQUIRED — every candidate is new + mechanism): (a) publish-bearing units are INELIGIBLE for + adoption (a writer that died re-derives always; its re-publish + re-grounds the value and ordinary retraction/observation clears + readers) — narrowest, keeps rows-only honest, costs adoption + efficiency for writers only; (b) adoption extends to session + publishes (writer-stamp rewrite + re-announce) — re-opens the + F17 exclusion argument and G-RULE-1's demand vocabulary, + heaviest; (c) a generation-alias table: `eAdopt` records + from→to and every stamp/liveness read evaluates through the + alias map — new durable state class, §7.5 tally change. Each + changes §3/§4a/§7 and the G2/G6 expectations; pick, pin, + re-derive the affected cells, and bring it back with the R2-F1 + pin for a targeted round 3. + +- **R2-F3 (MAJOR) — the premise digest canonicalizes a failed + revalidation as a bare outcome, so adopt fires across a genuine + upstream change (fail-vs-e2 ≡ fail-vs-e3); ADOPT is a new verdict + class the inherited P2/P3′ qualification never classifies, two + honest readings diverge on the constructed history, and §4a/§7's + "the adopting re-consult is strictly fresher" claim is false in + the FAIL shape.** + - Claim under attack: §4a's digest definition ("the consult result + (previous-artifact entry + revalidation outcome)") and its + walker-coherence paragraph ("the graph's re-consult is strictly + fresher... strengthens, never weakens"); §7 P2 ("a + marker-adopted scope's consult is the ADOPTING re-consult, this + attempt — strictly fresher than the walker's suppressed case"). + - Evidence, walked (budget-legal: 1 crash, epochs e1→e2→e3, one + scope, no sessions). Attempt 1: (S1, g1) consults — entry V1, + revalidation vs e2 FAILS → CHANGED-WITH-DIFF; the overlay unit + commits {copy base e1, overlay e1→e2, marker(g1, D), publish V2} + with D = H(entry V1, outcome FAIL). Checkpoint predates + completion (announce window); crash; upstream mutates e2→e3 + (between attempts — in scope per §1). Resume: bump g2; marker + found; recompute: entry V1 unchanged, revalidation vs e3 FAILS → + D′ = H(V1, FAIL) = D → ADOPT rows(e2) under upstream e3. The + premise the verdict actually depended on — WHICH upstream state + the diff fetched — changed; the digest cannot see it because a + failed revalidation yields no canonical token for the state it + failed against, and the diff content is fetched inside the + round, after the verdict. Now the readings: the adopting + re-consult performed a revalidation (FAIL) but NO fetch — under + MODEL_SPEC §7's round-5 F8 pin it is neither a validation match, + nor a fresh fetch, nor a changed-with-diff-with-fetch. Reading A + (adopt re-consult does not qualify): P2 green via attempt 1's + qualifying diff (any-attempt wording), P3′'s "last + consulted-against-upstream verdict" is attempt 1's at e2 → + expects rows(e2) → green. Reading B (the spec's own §7 sentence + makes the adopting re-consult THE consult): its epoch is e3 → + P3′ expects rows(e3) against sealed rows(e2) → RED. The sealed + content itself is smear-legal either way (coherent rows(e2)@V2, + staleness ≤ 1, self-healing next sync) — but the verdict + diverges by reading, and the "strictly fresher" justification is + false: in the FAIL shape the adopting re-consult qualifies + nothing, and freshness rests on the DEAD generation's original + fetch, exactly the walker's suppressed case, not stronger. Note + the walker never calibrated this shape: §7's P1 boundary note + confines every walker config to one interruption + one mutation; + suppress-after-diff-unit under a SECOND mutation is outside the + 6-overlay envelope — the adaptation extended the hand-off + without noticing. + - Why it matters: charge question 2's named target ("does any + input to a verdict escape it"). The escape is real, constructed, + and budget-legal; no scripted cell reaches it (G1's original + verdict is a MATCH), so it would be hardcoded away silently by + whatever the encoding does. + - Disposition (fix-without-re-review): pin adopt eligibility to + MATCH-outcome premises — a re-consult whose revalidation FAILS + re-derives regardless of the stored digest (cheap: FAIL means + upstream moved; the re-derivation fetches the current state and + "strictly fresher" becomes true), OR keep FAIL-adoption and pin + ADOPT's P2/P3′ classification explicitly (attempt-anchored + qualification; correct the §4a/§7 freshness prose). Register + ADOPT as a verdict class in the announce vocabulary either way, + and add the e1→e2→e3 FAIL-adopt history as a probe cell. + +- **R2-F4 (MAJOR) — marker lifecycle under supersession is not + total: the re-derive branch's `eMarkerPut` overwrite exists only + for unit-verdict re-derivations, a record-round re-derivation + (fetch-fresh) leaves the stale marker in place, and a later + premise flap-back ADOPTS content the marker no longer describes — + the exact hazard §11 question 6 hypothesized, constructed here + within budget.** + - Claim under attack: §4a's re-derive branch ("its new unit's + clear constituent supersedes the dead rows (§4b), and its + `eMarkerPut` overwrites the marker") — false for fetch-fresh + re-derivations, which are record rounds and commit NO marker + (the G8a pin); §4b's matrix (no marker column: no row says what + any incoming round does to an EXISTING marker); G1 leg (ii)'s + cell text (same misattribution: a failed revalidation yields + fetch-fresh per leg (i), so leg (ii)'s superseding round is a + RECORD round, not "the new unit"). + - Evidence, walked (budget-legal: 2 crashes, 3 attempts, epochs + e1→e2→e3 with content(e3) = content(e1) — value flap-back is in + scope per the walker's d1→d2→d1 precedent and truthful + validators). Attempt 1: (S1, g1) consults (V1, MATCH) → replay + unit + marker(g1, D = H(V1, MATCH)). Checkpoint in the announce + window (S1 pending); crash 1; mutate e1→e2. Attempt 2: bump g2; + marker found; recompute (V1 vs e2: FAIL) → differs → RE-DERIVE → + fetch-fresh → record round: `eClearScope` (removes g1's rows AND + fold contribution, §4b) + pages rows(e2) + publish V2 — and NO + `eMarkerPut` (G8a pin); nothing removes marker(g1, D), which now + describes a unit whose rows are gone. Checkpoint again in the + final-page announce window (S1 pending); crash 2; mutate e2→e3, + content reverting to e1's. Attempt 3: bump g3; marker check + finds marker(g1, D); recompute: entry V1, revalidation vs e3 + MATCHES (truthful validator: content unchanged vs V1's) → digest + EQUAL → ADOPT. Every constituent of `eAdopt` now operates on the + wrong object: the stamp rewrite substitutes g1→g3 and touches + nothing (the partition holds g2's rows, no g1 components — under + S they remain DEAD-stamped g2); the §4d fold transfer transfers + a contribution that was REMOVED at the §4b clear (incoherent + bookkeeping — meanwhile g2's dead complete round persists in the + fold per §4d); the re-announce announces rows(e2) as the adopted + content of a marker attesting replay-of-V1 = rows(e1). Seal, E + leg: partition rows(e2); the adopting re-consult was a MATCH — + which QUALIFIES under the F8 pin — so P3′'s last + consulted-against-upstream epoch is e3 and expects rows(e3) = + rows(e1) → P3′ RED on an honest history. S leg: the pass sees + the dead g2 stamps, forces re-runs that re-ADOPT through the + same stale marker without ever rewriting g2's stamps → the + R2-F2 no-progress loop shape again, from a different cause → + P6-S RED honest. The marker described content the store no + longer held, and adoption believed it. + - Why it matters: totality (charge question 6). The G8a pin is + correct in isolation; its ripple — who clears a marker a record + round strands — was never walked, and §12's own parenthetical + shows the pin was surfaced mid-draft. Adoption's soundness + silently assumes the invariant "marker present ⟹ the key's + partition IS the marked unit's outputs," and no rule maintains + it. + - Disposition (fix-without-re-review): add a MARKER column to + §4b's matrix making marker lifecycle total: any superseding + commit for a key removes-or-overwrites its marker (unit rounds + via their `eMarkerPut` constituent — already true; record + REPLACES rounds: `eClearScope` also deletes the marker, pinned + in §3's clear-placement pin; OVERLAY-intent records: no dead + base is legal, so no marker case arises — state it). Pin the + invariant explicitly and monitor it (marker ⟹ partition equals + the marked unit's outputs; announce-evidenced). Correct §4a's + re-derive branch ("its new ROUND supersedes; a unit round's + `eMarkerPut` overwrites the marker, a record round's clear + removes it") and G1 leg (ii)'s text. Add the flap-back history + as a probe cell (expected unreachable-after-pin). + +- **R2-F5 (MAJOR) — the admitted-derivation set has no death + semantics: a purged (E) or refusal-dropped (S) child's derivation + hash stays in the set, so the live generation's re-announce — by + adoption OR by at-least-once record redo — is suppressed and the + child starves on honest legs; jointly, E's purge predicate is + ∃/∀-ambiguous over fan-in edges and the two readings diverge on + G6c's declared E-leg verdict.** + - Claim under attack: G-RULE-2 ("the scheduler MAY suppress a node + admission iff the same derivation hash is already in the + ADMITTED-DERIVATION SET... this sync" — no removal rule + anywhere, and "may" leaves the load-bearing branch to the + encoding); §3's purge ("purges from the frontier every PENDING + node whose admitted-by edge names a dead generation" — ∃ or ∀ + over a fan-in node's edges?); G6c's E-leg ("E must exercise + refcounted support (C survives on S2's live support — no + retraction)... both keep C with zero redo"); §4a's starvation- + closure claim ("a lost child admission is re-derived from the + adopted rows' content"). + - Evidence, walked. (i) G6c, E leg: C is pending, demanded by S1 + AND S2 (two generation-qualified admitted-by edges); the crash + kills S1 mid-round; resume bumps S1 → C now has one DEAD edge + and one LIVE edge. Under the ∃-reading of §3's purge predicate C + is purged — contradicting the refcounted-support story the cell + asserts; under the ∀-reading C survives. Two honest readings, + one declared cell verdict. The S-side got the equivalent pin + ("S must not false-refuse (C's admission stamp contains a live + parent)"); E's purge predicate did not — asymmetric drafting. + (ii) The starvation composition, either variant: C's hash + entered the admitted-derivation set at ADMISSION (F13 pin) and + the set is checkpoint-durable. C is purged (E) or comes up for + dispatch before any live re-derivation and is refusal-dropped + (S: "otherwise it is dropped from the frontier without + executing"). The live parent's re-execution then re-derives the + SAME hash — S1@g2's at-least-once page-1 re-announce in a + paginated no-shrink config, or an adoption's row re-announce. + Demand derivation consults the set: the hash is present → + suppressed → C is in the frontier of no one, completed by no + one, and never re-admitted. Post-purge, the F13 completion rule + read against LIVE state (admitted ∧ ¬pending) even classifies C + as COMPLETED. The final closure lacks C; the env-side + counterfactual closure oracle fires RED on an honest, + mutant-free run — the oracle works exactly as F7's repair + intended, which is how we know the run is broken, not the + oracle. Adoption's F7(ii) closure claim survives only for + children whose admission was NEVER checkpointed (hash absent + after restore → re-admitted fresh) and for COMPLETED children + (suppression is then correct — G6a's ≈ 1 redo depends on it and + still derives); the purged/refused middle case starves. + - Why it matters: this is the composition of three round-1 + dispositions v2 applied individually and correctly (F5's + pending-only purge, F13's admission-keyed set, F1's re-announce) + — none wrong alone, jointly unsound. It is the graph's + single most load-bearing new mechanism (demand derivation) + failing silent-with-oracle on honest runs. + - Disposition (fix-without-re-review): pin (a) the purge predicate + as ∀ (purge only when EVERY admitted-by edge names a dead + generation — the refcount-consistent reading G6c's text already + assumes); (b) purge and refusal-drop REMOVE the node's + derivation hash from the admitted-derivation set (making + re-derivation re-admissible; G5e's count oracle is unaffected — + its epoch-2 shrink never re-derives the hash); (c) G-RULE-2's + "may" tightened to MUST-suppress iff the hash's node is pending + or completed, so the checker cannot legally choose starvation. + Re-derive G5f's honest baseline and G6c's E leg under the pins. + +- **R2-F6 (MAJOR) — G2's same-value control leg declares "P6-S red + ... recorded as redo," but P6-S's written form is a SEAL check and + the honest observation pass clears the evidence before seal: under + the at-seal reading the declared red is underivable (the leg walks + green), and under the at-observation reading P6-S is not the + property §7 registered — the F2(iii) value-blindness pin as + applied is incoherent with the pass it rides on.** + - Claim under attack: G2's control leg ("P6-S red on the S legs by + the value-blindness pin — recorded as redo"); §7 P6-S ("no + SEALED output carries a stamp containing a dead generation") + plus its value-blindness pin ("P6-S alarming on same-value + re-derivation is INTENDED — it checks the mechanism's + forced-redo promise"). + - Evidence, walked (scripted control premise: checkpoint captures + G completed ∧ H pending; crash; H@g2 re-derives d1 EXACTLY). + H@g2 re-publishes d1 under writer generation g2 (G-RULE-3 stamps + at emission; the value is identical, the writer stamp is not). + Pre-seal pass: G's rows carry {H: g1} dead → forces G's re-run. + G's re-execution finds its marker and recomputes premises: the + session re-read returns d1 with WRITER STAMP g2 ≠ g1 → digest + DIFFERS → RE-DERIVE → new rows carry {G: live, H: g2}, all live. + Seal: no sealed output carries a dead generation → P6-S GREEN as + written. The forced redo happened and is real — but it is a + RECORDED METRIC, not a property violation; if the pass works, + P6-S at seal cannot fire, and if P6-S fires at seal the pass + failed, which is a conformance failure, not "overhead." The two + readings (at-seal vs at-observation) flip a scripted leg's + declared verdict, and §10.1's adequacy discipline cannot tell an + intended red that never derives from a broken kill. + - Why it matters: the control leg is the declared exhibit of the + mechanism-vs-oracle distinction the F2 repair introduced; as + written it exhibits the confusion instead. + - Disposition (fix-without-re-review): recast the same-value + mechanism-conformance signal as what it is — a forced-redo COUNT + (observation-pass re-run events, announce-evidenced), recorded + in the redo column — and reserve P6-S red for sealed dead stamps + (mechanism failure). Correct the control leg's declared verdict + to: P6-G green, P6-S green, forced-redo count ≥ 1 (the + value-blindness pin's content, honestly stated). The + value-blindness PIN itself survives — dead-stamp-forced redo on + value-identical re-derivation remains intended behavior; only + its verdict vocabulary was wrong. + +## Minors + +- **R2-M1 (MINOR)** — the SESSION-READ observation point (variant S) + is named in §7.5's tally and the glossary but has no declared + transition in §3: what an execution does when a session read + returns a dead-stamped value (refuse? proceed and let the pre-seal + pass catch it? force the writer?) is unstated. No scripted leg + turns on it (reads are live at read time in every walked history), + but the tally counts it as S mechanism, so it must be registered + or struck. Fix-without-re-review. +- **R2-M2 (MINOR)** — `eAnnGenBump` at OBSERVATION/RETRACTION-forced + re-admissions has no commit carrier: those re-admissions are + scheduler steps, not store ops, while §2's monitor discipline is + announce-AT-COMMIT. The resume-time bump rides the forced resume + checkpoint's commit (clean); the mid-attempt bump's announce is + evidentially ungrounded. R2-F1's fence option (b) closes this for + free; otherwise pin the carrier. Fix-without-re-review. +- **R2-M3 (MINOR)** — marker store-scoping across syncs is + unregistered: §5 makes the marker durable in the artifact, the + budget runs 2-sync cells, and nothing says the §4a marker check + reads the CURRENT sync's store only (the walker's 3-atomic + precedent implies it; the graph spec never says it). A sealed + artifact also retains stale markers (R2-F4's history seals one + even after the fix, on the no-flap path) — pin that seal or sweep + drops marker rows, or that they are per-sync namespaced; note + §4c's "adopted-across-sync rows" wording invites the wrong + reading. Fix-without-re-review. +- **R2-M4 (MINOR)** — §4b's dead-base OVERLAY row explains detection + "via the marker's dead generation + no adoption," but record-path + keys HAVE no markers (G8a pin): for record-over-record the stated + detection channel does not exist and the precondition rests + entirely on scripted connector policy + the trust model. One + defensible intended meaning (the mutant, not the mechanism, is the + load-bearing part); the wording overclaims. Fix-without-re-review. +- **R2-M5 (MINOR)** — whether the ADOPTING execution's premise + re-reads register as tracked read edges (E+B) / merge into stamps + (S) is undeclared. The walked histories self-heal (the dead + generation's original read still grounds node-level retraction, + and digest equality pins the re-read stamp to the original), but + P6-E's quantification ("every reader execution of a dead value") + silently includes adopting re-readers only under one reading. + State it. Fix-without-re-review. +- **R2-M6 (MINOR)** — coverage gaps in the retraction machinery's + distinctive clauses: (i) the §3 keying pin's re-retraction clause + ("re-runs that themselves read a stale value... retracted again") + has no witness — G2's scripted checkpoint placement (G completed) + never produces a pre-re-publish re-run; add the G-pending + placement as a leg. (ii) Session-TRANSITIVE chains (a + reader-writer: retracted reader re-publishes, retracting + second-order readers) exist in no envelope config — the widened + envelope's readers do not write. Either script one reader-writer + leg or restate the inductive bet to exclude the shape explicitly. + (iii) No cell derives demand from a SESSION PUBLISH though + G-RULE-1 names publishes as demand sources (interacts with + R2-F2's rows-only re-announce). Fix-without-re-review. +- **R2-M7 (MINOR)** — the pre-seal pass's stated bound ("the §8 + attempt budget times the node count") is a category error: the + attempt budget bounds crash/resume attempts, and nothing in §8 + bounds INTRA-attempt observation-forced bumps per node (each bump + is a fresh generation; the state space is unbounded exactly where + R2-F2's loop lives). Add an explicit pass-iteration budget row to + §8 and re-word "finite by construction" to name the cutoff. + Fix-without-re-review. +- **R2-M8 (MINOR)** — poison × marker is unclassified: G8c's second + derivation poisons a scope whose first unit committed a marker; + a later forced re-run of the first node would find the marker, + recompute equal premises, and ADOPT a poisoned scope's rows — + re-announcing them into demand derivation. The seal excludes the + scope (SealExpect), so the direct content hazard is bounded, but + the matrix should say poison VOIDS the key's marker (no adoption + of poisoned content) and classify post-poison rounds for the key. + Fix-without-re-review. + +## Notes + +- **R2-N1 (NOTE)** — `eAdopt`'s precondition (fromGen is DEAD) is + unstated. A live-fromGen adoption is reachable only under + `suppressionOff` (G1's mutant leg: the sequential schedule's + second execution adopts a LIVE generation's unit), where the + declared legality alarm still derives; record the precondition so + the mutant's adopt path is a declared deviation, not an accident. +- **R2-N2 (NOTE)** — digest completeness is relative to the modeled + input set: config/compat drift and warm-install state are + unmodeled in every G cell (no drift scenario), so the digest omits + them VACUOUSLY; a cold re-consult would miss and force re-derive + (safe direction) if cold attempts were ever modeled. Add one + closure sentence to §4a ("the digest is total over the model's + verdict inputs: consult result and session reads; config/compat + are constants in every cell") so the vacuity is declared, per the + F15/F21 registration lesson. +- **R2-N3 (NOTE)** — P-GEN's monitor rule is implicit but derivable: + the checkable form is "no two ATTEMPTS contain store-commit + announces attributed to the same (n, g)" (attempt boundaries are + announce-visible; adoption re-announces attribute to the ADOPTING + execution, so they do not collide). Record the rule so the G1b + probe's evidence base is pinned — this is the affirmative answer + to charge question 7's F4 item. + +## Mechanical walks (the acceptance test for the repair) + +- **G1 leg (i)** (crash before unit commit): nothing durable; resume + bumps; re-consult V1 vs e2 FAILS → fetch-fresh → record round + (REPLACES: clear over empty, rows(e2), publish V2, no marker — + G8a-consistent). Fold = fresh(e2); P1/P2/P6-S green both variants. + **DERIVES as declared.** +- **G1 leg (ii)** (crash after unit commit): marker(g1, (V1, MATCH)) + found; recompute → FAIL vs e2 → digest differs → RE-DERIVE → + fetch-fresh → RECORD round; §4b's dead-rows/record/REPLACES row + removes g1's rows and fold contribution; seal rows(e2)@V2; fold = + fresh(e2); P6-S live. **Verdict GREEN DERIVES on both variants — + but via §4b's record row, NOT "the new unit's clear" (the cell + text and §4a's re-derive branch misattribute, R2-F4), and the + stale marker(g1) survives to seal (latent per R2-F4/R2-M3; + harmless in this cell's remaining history).** +- **G1 leg (iii)** (no mutation): marker found; recompute (V1, + MATCH) = D → ADOPT; `eAdopt` rewrites stamps g1→g2 (S: all live), + §4d transfers replacement(e1) — fold equals content; entry V1 + attests e1; P2's qualifying consult is the adopting re-consult + ITSELF (MATCH qualifies under the F8 pin — the "strictly fresher" + claim is TRUE in the match shape); rows re-announced. **DERIVES + as declared, both variants. This is the repair working.** +- **G1 mutant leg** (`suppressionOff`): racing schedule — both + consults pass the absent-marker check, two units commit, two + complete rounds with two copies → P1-LEGALITY RED first-find; + sequential schedule — second execution finds the first's marker, + premises equal, ADOPTS, seals coherent → green. **Flip confirmed + for the stated reason; first-find expectation correctly stated + in-cell. (Live-fromGen adoption in the sequential schedule: + R2-N1.)** +- **G2 E+A**: nothing forces G's re-run; seal embeds d1 ≠ final live + d2 → P6-G RED. **DERIVES as declared** (the F2 repair works: the + red now has a property). Marker machinery never engages (G never + re-runs) — no §4a interaction. +- **G2 E+B**: re-publish → retraction → G re-runs → marker found → + recompute: session value identity+writer-stamp differ → RE-DERIVE + → unit clears, embeds d2, `eMarkerPut` overwrites → P6-G GREEN. + **DERIVES under the scripted checkpoint placement AND the + kill-on-death reading of mid-attempt bumps; under the + run-to-completion reading the dead-in-flight schedule seals d1 → + R2-F1. Conditionally derivable.** `retractionOff` kill: no + re-run, sealed d1 → P6-G RED — **flips, mechanism-independent + oracle confirmed.** +- **G2 S+A and S+B**: resume bumps H (pending); H re-derives d2, + re-publishes; pre-seal pass sees {H: g1} dead in G's rows → forces + G → recompute differs (identity and writer stamp) → re-derive → + seal embeds d2, all stamps live → P6-G GREEN, P6-S green; the + pass CONVERGES here because the writer re-derived live (contrast + R2-F2's adopt placement). **DERIVE as declared.** `stampMergeOff` + kill: G's rows carry no H component; the pass is blind; sealed d1 + → P6-G RED — **flips against the oracle, not against itself — + the F2 repair's exact design goal, confirmed.** +- **G2 same-value control leg**: walks P6-G green / P6-S GREEN at + seal with forced-redo ≥ 1 — the declared "P6-S red" does not + derive → **R2-F6.** In the announce-window placement (H's unit + committed, H pending) the leg instead walks into R2-F2's adopt + loop → honest P6-S/P6-E reds. **The control leg is the repair's + soft spot, both directions.** + +## Answers to the §11 round-2 charge + +1. **Adoption/re-derivation interleaving under 2 workers**: row-level + MIXED content cannot seal — units and `eAdopt` are single atomic + store ops, and every §4b/§4a path is clear-based, so the store + holds one round's rows at any commit boundary. The race that + survives is WORSE than mixing: under the run-to-completion + reading of mid-attempt death, a dead execution's late atomic unit + (clear included) replaces a live re-derivation wholesale and E + seals it — FINDING R2-F1. Adopt-vs-adopt and adopt-vs-re-derive + orderings are otherwise sound: eAdopt-then-clear ends at the live + unit; clear-then-eAdopt makes the substitution a no-op with stale + marker metadata (subsumed by R2-F4's lifecycle rule). +2. **Premise-digest completeness**: NO for two inputs. (i) The + upstream state behind a FAILED revalidation escapes (outcome-bit + canonicalization) — adopt fires across e2→e3; concrete history + constructed in R2-F3. (ii) The writer-generation liveness of + embedded session values is changed by adoption itself and is + unrepairable by the digest (R2-F2). The previous artifact's + identity is adequately covered by entry + truthful validators; + warm/cold and config/compat are vacuously absent (R2-N2). +3. **eAdopt stamp-rewrite vs eAnnGenBump ordering**: sound at resume + — the forced resume checkpoint's commit carries the bump announce + and precedes any dispatch, so a monitor processes death before + any adoption's re-announce; commit-order delivery + (announce-at-commit) makes the dead-set current when rewritten + stamps arrive. Mid-attempt bumps lack a commit carrier (R2-M2). + A monitor CAN see dead-stamped row announces after a death + announce (the R2-F1 late commit); P6-S being a seal check means + the window itself doesn't false-alarm — the defect is R2-F1's, + not an ordering unsoundness. +4. **§4d back-port coherence**: COHERENT — verified by re-deriving + the v11 cells under §4d. The removal clause (supersession removes + a complete round's fold/count contribution) is DEATH-GATED and + therefore vacuous in the walker (no death): cell 4's locks-off + two-copy legality red survives (both rounds live, nothing + removed); 6-overlay-last w1's ONE-count survives (the incomplete + round was never counted — completion-counting, decision 19, + untouched); 6-naive's content alarm survives (debris is + incomplete either way); empty-fold attestation (decision 20) + fires exactly as pinned — §4d's marker-adopted seal folds the + transferred round, so the fold is non-empty precisely where the + walker's suppressed seal was green. One caveat: keep the removal + clause death-gated verbatim; a live-rows removal reading would + dissolve cell 4's alarm. The transfer-of-a-removed-contribution + incoherence in R2-F4's history is a §4a-composition defect, not + a back-port defect. +5. **Pre-seal fixpoint finiteness**: the model TERMINATES only by + cutoff, and the stated bound is not even the right budget + (R2-M7). Convergence holds when every dead stamp component + belongs to a node that re-derives live (all scripted main legs); + it FAILS on honest histories where the dead component is a + session writer's and the writer ADOPTED (rows-only re-grounding — + R2-F2) or where re-adoption cycles through a stale marker + (R2-F4): the pass forces the rows' producer, which cannot clear + an embedded dead component, and iteration makes no progress. + With `stampMergeOff` the pass is trivially convergent (blind); + `retractionOff` is E-only and does not interact. The claim as + written conceals the non-converging class. +6. **G8a pin + §4b joint totality**: NOT total. Round shapes are + covered (every verdict class maps to unit or record; ADOPT is + pinned as a transfer, not a round; poison-blocked rounds need a + classification sentence — R2-M8). Marker STATES are not: the + matrix has no marker column, the stale-marker-over-record-rows + state is constructible within budget, and the charge's + hypothesized walk — fetch-fresh leaves the stale marker; a later + consult adopts content the marker no longer describes — is + confirmed REACHABLE and misbehaves in both variants (R2-F4). + The pin's same-sync consequences also misfire in §4a's own + re-derive text (unit-only overwrite). Cross-sync, the marker's + store-scoping is unregistered (R2-M3) but the intended walker + reading (current-sync store only) makes the pin total there. +7. **Round-1 leftovers**: F4 — APPLIED CORRECTLY; ordering pin + explicit in §5, G1b probe + `resumeCkptOff` kill well-formed; + P-GEN is checkable via attempt-scoped announce attribution + (rule recorded as R2-N3). F5 — APPLIED CORRECTLY; the + checkpoint-consistent rebuild target is well-defined in G5e's + mid-round premise (a deterministic function of restored frontier + + generation-qualified admitted-by edges + durable store, all + announce-reconstructible; the dead-edge child purges cleanly + after the bump). The COMPOSITION defect found nearby (purge × + admitted-derivation set, purge predicate under fan-in) is new — + R2-F5, not a mis-application of F5. F9 — MOSTLY SUFFICIENT: + depth 2 exercises E's support-transitive retraction (G6b: S1's + changed re-derivation drops C's support, C's death drops GC's — + the machinery executes), fan-in exercises the refcount (G6c, + modulo R2-F5's purge-predicate pin). Still unexercised: + session-transitive (reader-writer) chains and the re-retraction + clause — R2-M6; declare or script. + +## Interlock spot-checks (F2/F3/F6/F7 dispositions × §4a) + +- **F2 × §4a**: the laundering oracle is genuinely + mechanism-independent — both G2 kills flip against P6-G with + adoption active (walked above); adoption cannot defeat a + retraction/observation-forced re-run whose premises changed (the + digest sees the value change) — the round-1 F1 defeat is closed. + Defects at the seam: the observation pass × adoption progress + failure (R2-F2), the value-blindness pin's verdict vocabulary + (R2-F6), the session-read observation point's missing transition + (R2-M1). +- **F3 × §4a**: §4d composes with adopt (transfer) and re-derive + (removal) correctly in every scripted cell; back-port coherent + (charge answer 4). The one incoherence — transferring a removed + contribution — arises only through R2-F4's stale marker. +- **F6 × §4a**: the matrix's four row-classes compose with + adoption's clear-based branches; the poison exemption is coherent + (G8c's alarm is the poison; counting exempted, legality preserved + elsewhere). Gaps: the missing marker column (R2-F4), poison × + marker (R2-M8), the dead-base detection wording (R2-M4). +- **F7 × §4a**: adoption's row re-announce makes the ghost closure + well-defined across deaths as claimed, and the env-side + counterfactual closure is genuinely independent (it is what + catches R2-F5's starvation). The starvation hole is closed for + never-checkpointed and completed children; the purged/refused + middle case re-opens it via the admitted-set composition (R2-F5). + `eAnnGenBump` evidence base: sound at resume, carrier gap + mid-attempt (R2-M2). + +## Verified clean (for the revision record) + +- The adopt-on-equal MATCH path is a faithful, strictly-stronger + adaptation of the walker's clause (iii): same-sync consult + provenance becomes this-attempt re-consult provenance, P2's + qualification holds via the adopting MATCH itself, and the + 6-atomic hand-off content seals identically (G1 leg (iii)). The + walker-coherence paragraph's degeneration argument is correct FOR + MATCH premises; only the FAIL shape overclaims (R2-F3). +- Fold/count transfer and removal (§4d) re-derive P1 correctly in + every scripted G1/G2/G5/G8 history walked; replacement-count + legality never double-counts an adopted copy (adoption commits no + copy) and never loses the mutant legs' alarms. +- `eAdopt` atomicity: single store op, announce-at-commit, rows + re-announced under the adopting execution's attribution — P-GEN, + P5's ghost closure, and G-RULE-1's per-announce timing all remain + well-grounded; no torn adoption state is constructible. +- The no-relitigation boundary is respected in both directions: v2 + did not re-open the walker verdicts, and this review's findings + are all about §4a's own seams or v2-new compositions, not about + round-1 dispositions as applied. +- Public-repo hygiene: clean. No customer names, tenant + identifiers, or internal infrastructure in v2 or in this review. + +## Summary + +| finding | severity | one line | disposition | +|---|---|---|---| +| R2-F1 | MAJOR | mid-attempt death of an in-flight execution unpinned; dead unit's late clear+commit wipes a live re-derivation; G2 E+B red under one honest reading | pin quiesce-before-bump (or store death fence, tally-amended) + retraction-queue semantics + probe cell; fix-without-re-review | +| R2-F2 | MAJOR | rows-only adoption strands dead session publishes; observation pass loses progress (budget-exhaustion seals dead stamps, honest P6-S/P6-E reds); G6 redo expectations placement-dependent | writer-adoption ineligibility vs publish re-grounding vs generation aliasing — new mechanism either way; **re-review-required** | +| R2-F3 | MAJOR | digest's FAIL-outcome canonicalization adopts across a real upstream change; ADOPT unclassified in P2/P3′ qualification (readings diverge); "strictly fresher" false in the FAIL shape | pin adopt-eligibility to MATCH premises (or classify ADOPT explicitly), register the verdict class, probe cell; fix-without-re-review | +| R2-F4 | MAJOR | marker lifecycle not total: record-round re-derive strands the stale marker; flap-back premise ADOPTS content the marker no longer describes (P3′/P6-S reds on honest history); §4a re-derive text false for fetch-fresh | marker column in §4b (supersession removes/overwrites), marker⟺content invariant + monitor, text corrections, probe cell; fix-without-re-review | +| R2-F5 | MAJOR | admitted-derivation set has no death semantics (purged/refused child's hash suppresses its own re-admission → honest starvation); E purge predicate ∃/∀-ambiguous over fan-in, flipping G6c's E leg | ∀-purge pin; purge/refusal remove the hash; suppression scoped MUST over pending∨completed; re-derive G5f/G6c; fix-without-re-review | +| R2-F6 | MAJOR | G2 control leg's declared "P6-S red" underivable at seal (the pass clears the evidence); value-blindness pin's verdict vocabulary conflates property with forced-redo metric | recast as forced-redo count; P6-S red reserved for sealed dead stamps; correct the leg's declaration; fix-without-re-review | +| R2-M1 | MINOR | session-read observation point in tally/glossary but no §3 transition | register or strike; fix-without-re-review | +| R2-M2 | MINOR | mid-attempt eAnnGenBump has no commit carrier (announce-at-commit discipline) | pin the carrier (free under R2-F1's fence option); fix-without-re-review | +| R2-M3 | MINOR | marker store-scoping across syncs unregistered; sealed stale markers as artifact debris; §4c wording | per-sync scoping pin + seal/sweep drops markers; fix-without-re-review | +| R2-M4 | MINOR | §4b dead-base detection "via the marker" overclaims for markerless record keys | wording (scripted policy + trust model); fix-without-re-review | +| R2-M5 | MINOR | adopting execution's premise re-reads: tracked-edge/stamp-merge status undeclared | one-sentence pin; fix-without-re-review | +| R2-M6 | MINOR | re-retraction clause, reader-writer session chains, and publish-derived demand unexercised by any leg | add legs or restate the inductive bet; fix-without-re-review | +| R2-M7 | MINOR | pre-seal pass bound is a category error (attempt budget ≠ intra-attempt bump budget) | §8 iteration-budget row + re-word "finite by construction"; fix-without-re-review | +| R2-M8 | MINOR | poison × marker unclassified (adoption of poisoned rows constructible) | poison voids the marker; classify post-poison rounds; fix-without-re-review | +| R2-N1 | NOTE | eAdopt's fromGen-dead precondition unstated (mutant-only reachable) | record it | +| R2-N2 | NOTE | digest completeness vacuous over unmodeled config/compat inputs | closure sentence in §4a | +| R2-N3 | NOTE | P-GEN's per-(n,g)-per-attempt monitor rule implicit | record it (charge Q7/F4 answer) | diff --git a/formal/reviews/graph-spec-round3-repairs.md b/formal/reviews/graph-spec-round3-repairs.md new file mode 100644 index 000000000..6c5e5d3f8 --- /dev/null +++ b/formal/reviews/graph-spec-round3-repairs.md @@ -0,0 +1,657 @@ +# Round 3 (TARGETED) — the round-2 repairs and their composition, GRAPH_MODEL_SPEC v3 + +Scope: the targeted round-3 spot review the round-2 disposition of +R2-F2 required, executing v3's §11 charge verbatim: (1) +writer-adoption ineligibility and its convergence argument; (2) +quiesce-before-bump composed with the retraction queue and the +pre-seal pass; (3) marker lifecycle totality (§4b marker column + +per-sync scoping + poison voiding + P-MARK); (4) admitted-set death +semantics under G-RULE-2's MUST-suppress; (5) MATCH-only adoption +and the G1c oracle; (6) the corrected G2 table, all legs and all +three new kills; (7) regression spot-check of round-2's +verified-clean results. Secondary (registration-grade): the round-2 +minors/notes as applied. Anchors: `formal/MODEL_SPEC.md` v11 FROZEN ++ MS-CO-001 (§7 pins incl. round-5 F8 and round-7 F2/F3; §9.6 +V-ATOMIC / V-OVERLAY-UNIT and their consult-surface and elision +inheritance), `formal/GLOSSARY.md`, `formal/walker/CALIBRATION.md` +decisions 19–24, `formal/reviews/graph-spec-round1.md`, +`formal/reviews/graph-spec-round2-adoption.md` (the acceptance +baseline — its verified-clean walks and its majors' dispositions as +applied are NOT relitigated; only their v3 composition is in scope). + +Method: mechanical walks of every honest history the charge names — +announce-window placements, two-crash compositions, mid-attempt +deaths under the quiesce pin, the G-pending and same-value G2 legs, +the G8d flap-back and G8c poison probes, the G5f/G6c re-derived +baselines — under 2 workers, ≤ 2 crashes, ≤ 3 attempts, ≤ 3 epochs, +pass-iteration budget ≤ 3, per §8; independent re-derivation of +P1/P2/P3′/P-GEN/P-MARK/P6-G/P6-E/P6-S and the closure oracle over +every walked history; kill-flip derivation for `writerAdopt`, +`quiesceOff`, `markerCleanupOff`, `adoptOnFail`, plus regression +flips for the inherited toggles; a durability sweep of §5's new and +amended rows (marker, mid-attempt bumps, retraction queue / pass +state) against crash and announce-in-flight placements; a totality +sweep of §4b's marker column over every marker state a walk can +construct; a chassis-constructibility check for every leg the charge +names (can the scripted premise exist under the declared semantics — +the round-1 F5(iii) discipline). + +Verdict: **REJECT — 2 majors + 4 minors + 3 notes. Both majors are +fix-without-re-review; NO finding is re-review-required.** All six +round-2 majors are soundly repaired as applied: the +writer-ineligibility core is sound (every scripted dead-writer +history re-derives live and the pass converges within budget — the +convergence argument the round-2 charge found missing now derives +mechanically on every scripted honest history), quiesce-before-bump +closes R2-F1's wipe in every schedule walked and cannot starve the +pass or deadlock, the marker lifecycle matrix is total over every +constructible marker state, the admitted-set death semantics close +the starvation/double-admission space under two workers, MATCH-only +adoption is classifiable in every scripted cell with SealExpect as +the correct oracle, and the corrected G2 table derives leg by leg. +The two majors are v3-composition seams the repairs newly expose, +not defects in the repairs as specified: (R3-F1) the +writer-ineligibility machinery — including its `writerAdopt` kill — +rests on an UNREGISTERED semantics choice about whether a +replay-verdict re-derivation re-performs session publishes, and the +two honest readings diverge on the kill's fireability and on the +convergence claim itself; (R3-F2) mid-attempt-minted generations are +not durably fenced, so a budget-legal two-crash history REUSES a +generation id and P-GEN fires red on an honest run — round-1 F4's +hazard resurrected through the retraction-queue path that v3's own +pins made walkable for the first time. Both repairs are one-pin +registrations of disciplines the spec already practices elsewhere; +the fixed spec needs a disposition registration check, not a fourth +adversarial round. + +## Majors + +- **R3-F1 (MAJOR) — whether a re-derivation whose re-consult MATCHes + (a replay-verdict round) re-performs the node's session publishes + is unregistered; the two honest readings diverge on the + `writerAdopt` kill's fireability (under the glossary's elision + reading the kill is structurally unfireable in every legal + chassis), and under the same reading a budget-legal writer + flap-back history strands a dead publish on an HONEST run — + falsifying §4a's "transient by construction" convergence claim and + breaking the R2-M1 writer-pending invariant the spec declares + checkable.** + - Claim under attack: §4a's convergence rationale ("the writer's + forced re-derivation re-publishes under its live generation + (same value or not)"); §6's `writerAdopt` row ("G2 + announce-window legs ... S: P6-S RED at seal ... E+B: P6-E + RED"); G2's announce-window leg ("publish-bearing unit committed + ... re-derives → re-publishes"); §3's session-read invariant + ("the dead value's writer is pending by construction"); + `formal/GLOSSARY.md`'s elision pin ("session writes (and reads) + the elided enumeration would have made do not occur this sync"). + - Evidence, walked. The model must pick one of two readings of + what a node execution's session publishes are. READING E + (elision, the glossary/walker anchor): publishes ride the + enumeration; a MATCH verdict's replay round elides them, so + publish-bearing markers arise only from CHANGED-WITH-DIFF units + (fetch-fresh rounds carry no marker, G8a). READING B (body-op, + the reading round 2's accepted walks silently used — R2-F2's own + evidence history has H committing a publish-bearing unit under a + no-mutation premise, constructible only if publishes are + node-body store ops independent of the verdict class): + publishes execute on every non-adopted execution. The spec + registers neither. Now the divergences, both within budget: + (i) THE KILL. `writerAdopt` removes writer-ineligibility only; + MATCH-only (R2-F3's pin) still applies, so the mutant fires only + where an adoption is otherwise eligible: marker present, MATCH + re-consult, digest equal. Under READING E every publish-bearing + marker is a diff unit whose digest records a FAIL outcome; an + adoption additionally needs a MATCH re-consult, whose digest + then differs (FAIL ≠ MATCH) → re-derive regardless of the + mutant. Exhaustive over chassis: stable premise (no + between-attempt mutation) → re-consult FAILs again (the consult + surface is the PREVIOUS artifact, §9.6 o-iii carried "as + everywhere", so the current sync's V2 publish never converts the + verdict) → MATCH-only blocks; flap-back mutation → MATCH but + digest differs → blocks. The kill CANNOT fire in any legal + history — a tabled kill for the round-3 re-review target's + load-bearing machinery that cannot flip, the §10.1 + recommendation-halting class (round-1 F5(iv) precedent). Under + READING B a replay-verdict publish-bearing unit is constructible + (MATCH premise, body publish), the announce-window chassis + exists, and the kill fires exactly as declared: H@g2 adopts → + no re-execution → no re-publish → d1 stays writer-stamped + g1-dead → the pass forces G, G's re-read returns (d1, g1) + unchanged → digest EQUAL → G re-adopts → no progress per + iteration → budget exhausts → sealed dead stamps → P6-S RED + (R2-F2's loop as a kill, verbatim); E+B: no re-publish → no + retraction → G never re-runs → P6-E RED. One toggle, one + scripted leg, two honest readings, opposite fireability. + (ii) THE HONEST HOLE. Under READING E, walk the writer + flap-back (budget-legal: 1 crash, 2 mutations — the G8d shape on + a writer): sync 2 warm; upstream e1→e2 before the sync; H's + consult hits V1, revalidation FAILS → CHANGED-WITH-DIFF; the + diff enumeration publishes d1; the overlay unit commits with + marker(g1, (V1, FAIL), publishBearing=1); reader G completes + embedding d1 with {H: g1}; checkpoint in H's announce window; + crash; upstream mutates e2→e3 with content(e3) = content(e1). + Resume: bump; H@g2 is adoption-INELIGIBLE (bit) → re-derives → + re-consult: V1 vs e3 MATCHES (truthful validator; content + reverted) → verdict REPLAY → the replay unit ELIDES the + enumeration → NO re-publish. The dead publish d1@g1 is stranded + exactly as in R2-F2's loop, with writer-ineligibility ON and + honestly obeyed: G's premise re-read returns (d1, g1) unchanged + → digest EQUAL → G adopts through unchanged premises forever → + the pass budget-exhausts → P6-S RED honest; under E+B no + re-publish means no retraction → P6-E RED honest. The §3 + session-read invariant ("the dead value's writer is pending by + construction") is also violated on this history — H completed + without clearing the value — so the model's own declared + checkable invariant fires on an honest run. Under READING B the + same history converges (the replay re-derivation's body + re-publishes d1@g2; digest differs; G re-derives; two pass + iterations). No SCRIPTED cell schedules a flap-back mutation on + a session writer, so no scripted honest verdict flips today — + the divergence that flips a scripted verdict is the kill leg, + (i). + - Why it matters: this is the round-3 charge's question 1 asked + and answered in the negative under one honest reading — the + convergence argument is sound only under a semantics the spec + never states, and the repair's OWN kill (the evidence that the + ineligibility bit is load-bearing) exists only under that same + unstated reading. It sits on the F17 exclusion boundary the + round-2 disposition was warned about: the within-sync + death-and-re-derive machinery constructs a sessions × replay + product (a replay-verdict re-run of a node that published this + sync) that §1's cross-sync exclusion argument does not cover. + - Disposition (fix-without-re-review): REGISTER READING B — one + §3/§4a pin: session publishes are node-body store ops, executed + by every non-adopted execution regardless of verdict class + (adoption alone skips them, which is exactly what the + eligibility bit exists to prevent); declared as a within-sync + deviation from the walker's elision vocabulary, with the + cross-sync sessions × replay product remaining excluded and + walker-owned (extend the §1 F17 sentence). This is a + registration of the reading round 2's accepted walks already + used, not new mechanism — under it, every declared verdict in + this review's walks derives (verified below): the + announce-window honest leg, both `writerAdopt` flips, the + writer flap-back history (converges), and the R2-M1 invariant. + Also register the announce-window leg's chassis (a + replay-verdict publish-bearing unit, MATCH-stable premise) so + the kill's adoption-eligibility is constructible by script, and + add the writer flap-back history as a probe leg (expected: pass + converges, forced-redo count ≥ 1). + +- **R3-F2 (MAJOR) — mid-attempt-minted generations are not durably + fenced: a retraction-forced bump commits (volatile), the new + generation dispatches and commits durable output, a crash lands + before any checkpoint (placement is a genuine choice point), and + the forced resume checkpoint re-mints the SAME generation id from + the restored table — G-RULE-3's "durably fenced" is false on a + budget-legal honest history, P-GEN fires red on it, and attempt-2 + debris reads as live in the window; round-1 F4's hazard + resurrected through the retraction path v3's own queue/quiesce + pins made walkable.** + - Claim under attack: G-RULE-3 ("generations are per-node monotone + counters, DURABLY FENCED: execution (n, g) exists only after + every (n, g' < g) is dead"); §5's generation-table row + ("latest-per-pending in checkpoints; death announce-visible") + and its mid-attempt-bump row ("volatile scheduler state whose + loss is self-healing"); §7 P-GEN ("no two attempts contain + store-commit announces attributed to the same (node, + generation)") as an every-cell monitor. + - Evidence, walked (budget-legal: E+B, the G-pending chassis, 2 + crashes, 1 mutation, 3 attempts, 1 worker suffices). Attempt 1: + H@g1 publishes d1; checkpoint captures G pending ∧ H pending + (mid-read-window); crash 1. Resume 1: forced resume checkpoint + cp1 commits {G@g2, H@g2H} (F4's pin, correctly applied — these + resume-minted ids are durable before dispatch). G@g2 dispatches, + reads stale d1, completes (unit commits, rows@g2). H@g2H + re-derives d2 (upstream moved), re-publishes → retraction entry + for reader G@g2 → G@g2 is quiesced (completed) → the bump + g2→g3 commits as a derived announce on H's completion carrier — + SCHEDULER STATE ONLY; §5 pins mid-attempt bumps volatile and no + rule forces a checkpoint here (placement is a choice point, and + the skip schedule is legal). G@g3 dispatches, re-derives, its + unit COMMITS DURABLY — rows and marker attributed (G, g3). + Crash 2, before any checkpoint. Resume 2: restore cp1 (the last + durable checkpoint: G pending@g2, H pending@g2H); forced resume + checkpoint bumps from the RESTORED table: G g2→g3, H g2H→g3H — + (G, g3) is re-minted. Attempt 3's (G, g3)′ dispatches and + commits (its marker check finds marker(g3) — its OWN id — + recomputes, digest differs on the dead H stamp, re-derives, a + second (G, g3)-attributed unit commits). Consequences, each + checked: (a) P-GEN's recorded rule fires — attempts 2 and 3 + both contain store-commit announces attributed to (G, g3) — an + honest RED from the monitor F4's repair installed; (b) + G-RULE-3's identity uniqueness is violated in effect (one + stamp, two producers — round-1 F4's exact phrasing); (c) in the + window before attempt 3's clear, attempt-2's rows@g3 (embedding + the dead {H: g2H} component) read as LIVE under the + dead-set-derivation rule (every generation below latest is + dead; g3 IS latest) — dead debris laundered live; content is + eventually rescued only because every unit/record path is + clear-based, which is luck of the mechanism, not a fence. + Reachability requires nothing exotic: a mid-attempt bump (any + retraction or observation re-admission), one post-bump durable + commit, and a crash with the checkpoint skipped. The scripted + G2/G1d configs arm one crash, so no CURRENT cell reaches it — + but §8 budgets two crashes, P-GEN is an every-cell monitor, and + the claim "durably fenced" is false as written. This walk was + not constructible in round 2: R2-F1 left the retraction queue's + enqueue/drain semantics unstated, so the post-bump dispatch + path had no pinned behavior to walk; v3's queue and quiesce + pins created the seam they now must fence. + - Why it matters: every death-keyed mechanism keys off generation + identity (round-1 F4's why-it-matters, verbatim applicable). + The forced-resume-checkpoint discipline exists precisely so + that no generation id is used before it is durable; v3 mints + ids on a second path and forgot the discipline there. + - Disposition (fix-without-re-review): extend the F4 discipline + to mid-attempt minting — pin that a mid-attempt bump's + generation-table delta is durable BEFORE the bumped generation + dispatches. Cleanest form, F4-parity, no new state class: the + bump forces an `eCheckpoint` commit (the checkpoint already + carries the generation table per G-RULE-4) between the bump's + carrier announce and the new generation's dispatch; the + alternative durable-max bump rule (resume bumps to + max(restored latest, highest generation in durable stamps for + the node) + 1 — round-1 F4's option (b)) is also sufficient and + touches only the resume rule. Verified under either pin: the + walk above mints g4 at resume 2 (or restores g3 as durable) — + no collision, P-GEN green, the dead-set derivation correct. + Amend §5's two rows ("self-healing" is true for the LOSS of the + bump's scheduling effect, not for id reuse — say so), add the + two-crash reuse history as a probe cell (expected + unreachable-after-pin), and give the pin a kill + (`midBumpFenceOff` → P-GEN RED), mirroring G1b/`resumeCkptOff`. + +## Minors + +- **R3-M1 (MINOR)** — G8d's honest-leg mechanism attribution is + wrong: attempt 3's consult HITS the previous artifact's V1 and + revalidates against e3 whose content equals e1's, so the truthful + validator MATCHES and the verdict is REPLAY, not "ordinary + fetch-fresh" as the cell text says. The cell's own mutant text + concedes this ("attempt 3 premise-matches it (V1 MATCH vs e3)") — + the honest leg's text contradicts its mutant leg. SealExpect + rows(e3) is verdict-equal either way (replay of the e1 base = + rows(e3)); text correction only, the round-2 G1(ii) class. + Fix-without-re-review. +- **R3-M2 (MINOR)** — eAdopt × poison has a check-then-act window + the matrix's "no adoption of poisoned content is EVER legal" + overclaims: the void bit is read at the worker-side marker check, + and a second derivation's poisoning commit can land between that + check and the `eAdopt` commit (2 workers; the N4/round-7-F6 window + class). G8c's scripted leg forces the re-run post-poison, so no + scripted verdict is affected, and the seal-exclusion bounds the + hazard either way — but "ever" needs a mechanism: pin a store-side + `eAdopt` precondition (refuse on a poisoned key — the same shape + as R2-N1's fromGen-dead precondition) or reword to the scripted + guarantee and record the window as a boundary note. + Fix-without-re-review. +- **R3-M3 (MINOR)** — the pre-seal pass's iteration boundary is + unstated: nothing says a scan begins only from a re-drained + frontier. The drain-gated reading is strongly implied (the pass + lives inside the seal sequence, whose precondition is a drained + frontier, and a forced re-admission un-drains it), and under it + every honest walk in this review converges in ≤ 2 iterations; an + eager-re-scan reading would burn the budget observing the same + dead stamp while the forced re-run is still in flight and make + the §10.8 convergence assertion measurement-dependent. One + sentence ("one iteration = one scan over a drained frontier"). + Fix-without-re-review. +- **R3-M4 (MINOR)** — §4a's convergence claim quantifies over "every + honest history" but the mechanism only guarantees convergence + when the dead component's writer is STILL DEMANDED: a writer + legitimately de-demanded by an epoch shrink (its parent's live + re-derivation no longer derives it; ∀-purge removes it) never + re-publishes, and a still-demanded reader of its sync-scoped + session value then carries an unclearable dead component — the + pass budget-exhausts and P6-S reds on an honest history, while + E+B seals green (a variant asymmetry worth recording). No + scripted cell composes sessions with a demand shrink (sessions + exist only in G2/G9, which script none), so no cell verdict is + affected; the CHECKED form ("every honest cell converges") is + true. Scope the prose claim to the scripted envelope and add the + sessions × shrink exclusion to §1/§8's inductive-bet list (the + R2-M6(ii) treatment), or script the leg. Fix-without-re-review. + +## Notes + +- **R3-N1 (NOTE)** — the at-least-once cost claim for + writer-ineligibility is HONEST (charge question 1's second probe, + answered affirmatively): a publish-bearing round's rows are + re-derived, and every consequence is cost-shaped, not + verdict-shaped — §4d's supersession removal keeps + replacement-count legality at one (the dead round's copy leaves + the count at the clear), G-RULE-2's MUST-suppress over + pending∨completed prevents child re-execution (and a purged + child's re-admission via the re-announce is the intended redo), + P2 qualifies via the re-derivation's own consult, P3′/SealExpect + see identical or fresher content, and P-GEN attribution is clean. + No history was found where losing row-adoption changes a verdict. + Recorded for the bake-off's forced-redo bookkeeping. +- **R3-N2 (NOTE)** — the deferral non-interference arguments + (charge question 2) are sound and worth recording in §3 as two + sentences: (a) a deferred bump cannot starve the pass budget + because deferral requires an in-flight dying execution, which + means a non-drained frontier, and the pass only runs and iterates + from a drained frontier — every deferral resolves strictly before + the pass's first scan; (b) two workers' deferrals cannot deadlock + because a deferral waits on an execution's completion and no + execution's completion ever waits on a bump — the wait graph is + one-directional. Verified additionally: a crash that loses a + pending deferral is self-healing exactly as §5 claims (the resume + bump re-admits the reader regardless), MODULO R3-F2's fencing of + bumps that had already COMMITTED and dispatched. +- **R3-N3 (NOTE)** — the round-2 minors and notes are all applied as + dispositioned; registration sweep in its own section below. One + cross-reference: R2-M1's registered invariant is the honest-red + witness in R3-F1's reading-E history — the registration did its + job (it made the hole checkable), which is evidence for the + disposition discipline, not against the registration. + +## Mechanical walks (the acceptance test for the round-2 repairs) + +All walks under READING B where the reading matters (per R3-F1's +disposition — the reading round 2's accepted baseline used); +divergences under reading E are recorded in R3-F1 and not repeated. + +- **Writer convergence, announce-window (G2 new leg, honest)**: + checkpoint captures H pending, publish-bearing unit committed + (d1@g1 durable); G completed embedding {G: gG, H: g1}. Crash. + Resume: forced checkpoint commits H@g2; marker check — + publishBearing set → INELIGIBLE → re-derive → re-publish d1@g2. + E+B: retraction keyed (key, d1, g1) fires on the re-publish → + G re-admitted → re-reads d1@g2 → digest differs (writer stamp) → + re-derives → embeds live → queue drains → seal d2... seal d1@g2 + content, equal to the final live derived value → P6-G GREEN. S: + frontier drains (H completed) → pass scan 1: G's rows carry + {H: g1} dead → force G → re-read d1@g2 → digest differs → + re-derive → scan 2 clean → CONVERGED in 2 ≤ 3. P6-S green. + **Derives as declared.** +- **Writer convergence, two crashes**: the same chassis with crash 2 + in H@g2's announce window (checkpoint captures H pending, g2 unit + + publish committed). Resume 2: bump g3 (resume-minted, durable at + the forced checkpoint — fenced); marker(g2, publishBearing) → + ineligible → re-derive → re-publish d1@g3 → readers cleared as + above → pass converges in 2. Attempts: 3 ≤ 3. **Derives.** (The + UNFENCED two-crash shape — crash 2 after a MID-ATTEMPT bump's + post-dispatch commit — is R3-F2, a different placement.) +- **Writer mid-attempt death**: unreachable in-envelope — a writer + is retraction-bumped only if it reads a re-published value + (reader-writer, excluded §1/§8) and observation-bumped only via + dead components in its own rows (same exclusion). Writer death is + resume-path only; the convergence argument needs exactly the + resume path. **Vacuity confirmed, correctly fenced by the + declared exclusions.** +- **G1d honest (quiesce)**: retraction bump lands while dying reader + G@g2 is in flight → DEFERS → G@g2 completes (late unit commits, + embedding stale d1, marker g2) → bump commits atomically with the + completion announce → G@g3 dispatches → marker(g2) found, reader + bit clear → premises recompute: reads d2@g2H → digest differs → + RE-DERIVES → its clear removes g2's rows → last writer → queue + entry removed at G@g3's completion → queue empty → seal embeds d2 + → P6-G GREEN. **Derives as declared.** +- **G1d mutant (`quiesceOff`)**: bump commits immediately; G@g3 + re-derives d2 on the free worker and commits; the never-cancelled + G@g2 then commits its late atomic unit — clear wipes g3's live + rows, installs d1 — no further re-publish, queue drains, seal + embeds d1 ≠ final live d2 → P6-G RED. **Flips for the stated + reason.** +- **G8d honest (flap-back)**: attempt 1 replay unit + marker(g1, + (V1, MATCH)); crash 1; e1→e2; attempt 2 marker found, FAIL → + MATCH-only → re-derive → fetch-fresh RECORD round — `eClearScope` + removes g1's rows AND DELETES the marker (the v3 pin) → rows(e2) + + V2; crash 2 in the announce window; e2→e3 (content = e1's). + Attempt 3: NO marker → ordinary consult → V1 MATCHES vs e3 → + replay unit (not fetch-fresh — R3-M1) → clear removes g2's dead + rows → seals rows(e3) → SealExpect GREEN, P-MARK vacuous-to-true + throughout, P1 fold = replacement(e1) = rows(e3). **Derives; + verdict as declared, mechanism attribution corrected.** +- **G8d mutant (`markerCleanupOff`)**: the clear leaves marker(g1, + (V1, MATCH)); attempt 3 finds it, recomputes (V1, MATCH) → digest + EQUAL, bit clear → ADOPTS — while the partition holds g2's + rows(e2) that the marker never described → P-MARK RED (marker ⟹ + partition equals the marked round's outputs; announce-evidenced + from attempt 2's record round onward); under E the adopting MATCH + qualifies → P3′ expects rows(e3) = rows(e1) against sealed + rows(e2) → P3′ RED. **Flips for the stated reasons, both + monitors.** +- **G8c post-poison leg**: second distinct derivation's first commit + poisons the scope AND voids the marker; the scripted forced + re-run finds a voided marker → re-derive-or-refuse (no adoption) + → post-poison rounds commit legally → scope seal-excluded + (SealExpect) → P1 legality exempt (the poison is the alarm). + **Derives as declared.** The unscripted marker-check/eAdopt + commit race is R3-M2 (boundary window, no scripted verdict + affected). +- **Marker-state totality hunt**: states {absent, present(g, D, + bit), voided} × transitions {unit put (overwrite), REPLACES clear + (delete), poison (void), eAdopt (generation update, digest and + bit invariant — premises equal by definition), seal (drop — + per-sync), crash (durable, no change), purge (no change; rows + swept at seal, marker dropped at seal — P-MARK holds + throughout)}. Live-rows record rounds for a marked key are + unreachable except through the poison row (a unit round is + single-op, so same-derivation continuation cannot follow it; a + second execution of the node requires death → dead rows; distinct + derivation → poison). OVERLAY-intent records over a marked key: + only via the illegal dead-base row (mutant-only). **No + unclassified marker state found; the matrix is total.** +- **G5f honest baseline (re-derived)**: no-shrink epoch; C admitted + and checkpointed; crash; C's only edge dead → ∀-purge removes C + AND its hash; the parent's live re-derivation (or adoption's row + re-announce) re-derives the hash → not pending, not completed + (hash removed, completion rule evaluated after removals) → MUST + admit → C re-runs → closure complete → GREEN; `demandDropOff` → + closure oracle RED. **Starvation unreachable, as the cell now + asserts; both directions derive.** +- **G6c E leg (re-derived)**: C has edges from S1 (dead after the + crash) and S2 (live) → ∀-purge does NOT fire → C survives, zero + extra redo; S leg: C runs under S1@g2's live re-derivation of the + hash (dispatch-time re-validation, no false refusal). **"Both + keep C with zero redo" derives under the pins.** +- **Two-worker admitted-set composition**: admissions are derived + per-announce, atomic with the carrier's bookkeeping (G-RULE-1), + and the scheduler serializes announce processing — two parents + deriving one hash admit once, suppress once (pending). Purge and + refusal are scheduler steps (resume-time / dispatch-time), never + concurrent with an admission of the same hash. Refusal-then- + re-announce re-admits; re-announce-then-dispatch runs under the + live re-derivation. **No suppress/starve gap, no double-admission + gap.** +- **G1c honest**: marker digest (V1, FAIL, ⊥); attempt 2 re-consult + FAILs vs e3 → MATCH-only forces re-derive → the re-derivation + fetches at e3 → SealExpect rows(e3) GREEN. Mutant `adoptOnFail`: + digest (V1, FAIL) equal → adopts rows(e2) across e2→e3 → + SealExpect RED. P3′ CANNOT catch the mutant (the FAIL re-consult + performs no fetch and does not qualify under the F8 pin, so the + last qualifying verdict is attempt 1's diff at e2, which expects + the mutant's own rows(e2)); P2 stays green via any-attempt + wording. **SealExpect is not just the right oracle — it is the + only oracle that flips; the walker 5b discipline correctly + applied. Both legs derive.** +- **G2 full table**: E+A — nothing re-runs G; seal embeds d1 ≠ + final live d2 → P6-G RED, derives. E+B — retraction → re-run + (quiesce-deferred where needed, G1d) → seal d2 → P6-G GREEN, now + UNCONDITIONAL (the round-2 conditional reading is closed by the + pin); `retractionOff` → P6-G RED. S+A/S+B — resume bumps H; H + re-derives d2 (FAIL vs moved upstream; marker ineligible or + absent), re-publishes; pass scan 1 forces G; digest differs; + re-derive; scan 2 clean → P6-G GREEN, P6-S green, converged; + `stampMergeOff` → the pass is blind, sealed d1 → P6-G RED + (mechanism-independent oracle confirmed again). SAME-VALUE + CONTROL — H@g2 re-derives d1 exactly, re-publishes under g2; + pass forces G on the dead {H: g1}; the re-read's writer stamp + differs → re-derive → all live → P6-G GREEN, P6-S GREEN at seal, + FORCED-REDO COUNT ≥ 1 (the pass-forced re-run's derived + announce) — the R2-F6 vocabulary now derives exactly as + declared. ANNOUNCE-WINDOW — walked above, derives (chassis + registration per R3-F1). `writerAdopt` — flips on both variants + for the stated reasons UNDER READING B (S: budget-exhausted seal + with dead stamps → P6-S RED; E+B: no re-publish → P6-E RED; + P6-G stays green on the same-value content, correctly + distinguishing oracle from mechanism); unfireable under reading + E — R3-F1 is prerequisite to citing this kill. G-PENDING — G's + pre-re-publish re-run reads stale d1 and completes; H re-publishes + d2; the re-retraction clause fires on the completed re-run + (quiesce trivially satisfied) → G re-runs again → embeds d2 → + P6-G GREEN; witnesses the keying pin's clause as intended. + **Every declared verdict derives; three kills flip (one + conditionally on R3-F1's registration).** + +## Regression spot-check (charge question 7) + +- **G1 legs (i)–(iii)**: (i) unchanged, GREEN derives (no marker + machinery engages). (ii) marker found → FAIL → re-derive → + record REPLACES — the clear now also deletes the marker; nothing + downstream in this history reads it; seal rows(e2)@V2 GREEN + derives, and the round-2 latent stale marker is gone. (iii) + MATCH, digest equal, publishBearing CLEAR (S1 neither reads nor + publishes sessions) → ADOPT → GREEN derives — writer-ineligibility + does not perturb the repair's flagship leg. `suppressionOff` + mutant: unchanged, P1-LEGALITY first-find with the R2-N1 declared + deviation. **Preserved.** +- **Fold back-port coherence (§4d)**: text unchanged and still + death-gated verbatim (the walker cell-4 caveat honored); the v2 + transfer-of-a-removed-contribution incoherence is unreachable now + that adoption requires a present marker and P-MARK ties the + marker to the partition's actual outputs; replacement-count + legality re-derived at one across every at-least-once redo walked + (the superseded round's copy leaves the count at its clear). + **Preserved.** +- **eAdopt atomicity**: still one store op; the v3 addition (marker + generation update inside the op) does not tear it; re-announce + attribution to the adopter unchanged; P5 ghost closure and + G-RULE-1 timing unaffected. **Preserved.** +- **P-GEN checkability**: the R2-N3 rule is recorded (G-RULE-3, §7) + and remains checkable; resume-path fencing (F4) intact — G1b and + `resumeCkptOff` well-formed. The MID-ATTEMPT minting path breaks + the rule's truth on an honest two-crash history — R3-F2, a new + v3-composition seam, not a regression of the round-2 verification + (which walked no post-bump-dispatch crash because the queue + semantics did not yet exist to walk). **Preserved on the round-2 + evidence base; extended surface broken — R3-F2.** +- **Inherited kills** (`sweepOff`, `sweepOverreach`, `purgeOff`, + `resumeCkptOff`, `overlayComposeDead`, `demandDropOff`, + `retractionOff`, `stampMergeOff`): none interacts with the v3 + pins in any walked history; G5e's count-oracle premise is + untouched by ∀-purge (its child has one dead edge). **Preserved.** + +## Round-2 minors/notes registration check (lighter touch) + +- **R2-M1** — session-read observation point registered in §3 as + read-through + derived dead-read announce + the writer-pending + invariant. APPLIED. (The invariant is load-bearing evidence in + R3-F1's reading-E history; under the R3-F1 pin it holds on every + honest history — re-verified.) +- **R2-M2** — derived-announce carrier pin registered in G-RULE-1; + resume bumps ride the forced checkpoint. APPLIED. (Durability of + the mid-attempt bump itself is R3-F2 — the carrier pin grounds + the ANNOUNCE, which is what R2-M2 asked.) +- **R2-M3** — per-sync marker scoping pinned in §3 (current-sync + store only; seal drops marker rows) and §4c's cross-sync wording + deleted; §5 row amended. APPLIED. +- **R2-M4** — §4b dead-base OVERLAY row reworded to scripted policy + + trust model, with `overlayComposeDead` as the load-bearing + check. APPLIED. +- **R2-M5** — adopting executions' premise re-reads register + normally, pinned in §3 and quantified into P6-E. APPLIED. +- **R2-M6** — (i) G-pending leg scripted and walked (derives); (ii) + session-transitive chains excluded with the keying-uniform + argument in §1 and restated in §8's inductive bet; (iii) + publish-derived demand excluded from G-RULE-1's vocabulary with a + change-order requirement. APPLIED. +- **R2-M7** — pass-iteration budget row in §8 (≤ 3), convergence a + checked expectation, budget-exhausted seal announce-visible. + APPLIED. (Iteration boundary wording — R3-M3.) +- **R2-M8** — poison voids the marker; post-poison rounds + classified; G8c's post-poison leg added and walked. APPLIED. + (Commit-order window — R3-M2.) +- **R2-N1/N2/N3** — eAdopt fromGen-dead precondition, digest-closure + vacuity sentence, P-GEN monitor rule: all recorded where the + dispositions specified. APPLIED. + +## Answers to the §11 round-3 charge + +1. **Writer-ineligibility convergence**: SOUND on every scripted + honest history under the operative (round-2-baseline) reading — + the dead writer is pending at resume, must complete before the + frontier drains, is barred from adoption by the bit, re-publishes + under its live generation, and retraction (E+B) or the + writer-stamp digest delta (S) clears every reader in one forced + re-run; the pass converges in ≤ 2 iterations in every walk, + including two-crash and announce-window placements; mid-attempt + writer death is unreachable in-envelope. The argument is + UNREGISTERED at its load-bearing step (does a replay-verdict + re-derivation re-publish) — R3-F1; and its "every honest + history" quantifier overreaches the mechanism for de-demanded + writers — R3-M4. Rows-owned-by-writers: cost-only, claim honest + — R3-N1. +2. **Quiesce composition**: no pass-budget starvation (deferrals + resolve strictly pre-drain), no two-worker deadlock (waits are + one-directional), crash-loss of a pending deferral self-heals + via the resume bump; G1d honest and mutant legs derive — R3-N2. + The COMMITTED-bump durability seam is R3-F2. +3. **Marker lifecycle totality**: total — every constructible + marker state and transition is classified by the §4b column plus + the per-sync and poison pins; P-MARK is preserved by every row + and fires exactly on the mutant; G8d honest and mutant derive + (one text misattribution, R3-M1); the eAdopt×poison window is + boundary-grade, R3-M2. No missing state found. +4. **Admitted-set death semantics**: compose cleanly — MUST-suppress + over pending∨completed with purge/refusal hash removal and the + after-removals completion rule closes both the starve and + double-admission gaps under two workers; G5f and G6c re-derive + as declared. +5. **MATCH-only adoption**: classifiable in every scripted cell — + every legal adoption's consult is its own MATCH (P2), P3′ + coheres through truthful validators, ADOPT is a registered + verdict class; G1c derives both legs and SealExpect is the only + oracle that can flip the mutant — the right oracle, confirmed. +6. **The corrected G2 table**: all seven legs derive; `quiesceOff` + and `markerCleanupOff` flip unconditionally for the stated + reasons; `writerAdopt` flips for the stated reasons ONLY under + the reading R3-F1 requires the spec to register — as written it + is unfireable under the equally honest elision reading. +7. **Regression**: round-2's verified-clean results preserved (G1 + legs, G2 axis legs, fold back-port, eAdopt atomicity, resume-path + P-GEN); the one break (R3-F2) is on a surface round 2 could not + walk, introduced by v3's own — otherwise correct — queue/quiesce + pins. + +## Verified clean (for the revision record) + +- The six round-2 majors are repaired as dispositioned and their + repairs compose in every scripted history walked; nothing in this + review re-opens a round-1 or round-2 disposition as applied, and + neither major is a defect in a repair's specified mechanism — + both are seams BETWEEN the repairs and pre-existing semantics + (elision vocabulary; generation-fencing discipline). +- The pass-iteration budget (R2-M7) is honest: every honest walk + converges in ≤ 2 of the budgeted 3 iterations, and the one + constructed budget-exhaustion (reading-E writer flap-back) is + exactly the class the budget-exhausted-seal red exists to catch. +- The §7.5 tally as amended reflects the v3 mechanisms accurately + (quiesce, queue semantics, eligibility pins, marker column, death + semantics, observation points + budget) and writer-ineligibility + is correctly charged to both variants as shared machinery in G6. +- G3, G4, G7, G9 are untouched by the v3 pins in every walked + history; G7's attempt-failure machinery composes with quiesce + (a loud failure's checkpoint captures pending state; a + never-committed deferral mints nothing and self-heals). +- Public-repo hygiene: clean. No customer names, tenant + identifiers, or internal infrastructure in v3 or in this review. + +## Summary + +| finding | severity | one line | disposition | +|---|---|---|---| +| R3-F1 | MAJOR | session-publish semantics under replay-verdict re-derivation unregistered; `writerAdopt` kill unfireable under the elision reading and the convergence claim fails on a budget-legal writer flap-back; all declared verdicts derive under the round-2-baseline body-op reading | register the body-op pin (+ F17 boundary sentence), register the announce-window chassis, add the writer flap-back probe; fix-without-re-review | +| R3-F2 | MAJOR | mid-attempt-minted generations not durably fenced: bump → dispatch → durable commit → crash-skip-checkpoint reuses the id; P-GEN red on honest two-crash history; G-RULE-3's "durably fenced" false | force durability of the bump's table delta before dispatch (checkpoint-at-bump or durable-max resume rule), amend §5, add reuse probe + fence kill; fix-without-re-review | +| R3-M1 | MINOR | G8d honest leg says "fetch-fresh" where truthful validators derive REPLAY (its own mutant text concedes MATCH); verdict unchanged | correct the cell text; fix-without-re-review | +| R3-M2 | MINOR | eAdopt × poison check-then-act window; "never legal" overclaims relative to worker-side check | store-side eAdopt poison precondition or boundary-note wording; fix-without-re-review | +| R3-M3 | MINOR | pass iteration boundary (scan from a drained frontier) implied but unstated | one-sentence pin; fix-without-re-review | +| R3-M4 | MINOR | convergence prose quantifies over histories the mechanism doesn't cover (de-demanded writer × sync-scoped session value); unreachable in scripted cells | scope the claim; declare the sessions × shrink exclusion in the inductive bet; fix-without-re-review | +| R3-N1 | NOTE | at-least-once cost claim for writer row re-derivation verified honest (count-legal, suppression-safe, verdict-neutral) | record | +| R3-N2 | NOTE | deferral non-starvation / non-deadlock arguments verified; record the two-line argument in §3 | record | +| R3-N3 | NOTE | round-2 minors/notes all applied as dispositioned (sweep above) | record | diff --git a/formal/reviews/model-spec-round1.md b/formal/reviews/model-spec-round1.md new file mode 100644 index 000000000..fea995cc8 --- /dev/null +++ b/formal/reviews/model-spec-round1.md @@ -0,0 +1,34 @@ +# Model spec adversarial review — round 1 + +Reviewer: independent agent (decorrelated from the spec author's session +context; formed its view from the brief, the frozen 6b contract, and the +code). Verdict: **REJECT** — 2 blockers, 8 majors, 3 minors, 2 notes. +Spec revision v2 addresses every finding; dispositions below. The full +review text is preserved in the review agent's transcript; this file +records the findings and their dispositions for the freeze record. + +| # | severity | finding (condensed) | disposition in spec v2 | +|---|---|---|---| +| 1 | BLOCKER | Restart-from-root does not fall out: the spec had workers return per-page continuations applied to the stack, so loop-top checkpoints could capture mid-chain cursors — a resume granularity hard crashes don't have (CO-6b-002). | §3 MWorker now owns an action's entire page chain (mirrors `syncOneAction`); stack entries keep root tokens until finish; loop-top checkpoints therefore contain only root tokens. Graceful-stop checkpoints (new, finding 3) are the one place mid-chain state becomes durable, and CO-6b-002's "unreachable in practice" claim becomes an explicit conformance question (§9 C1). | +| 2 | BLOCKER | P1 monitor vacuous: the "declared composition log" was the announced store ops, whose fold trivially equals the partition; the attestation clause was undefined and cannot be defined from the wire vocabulary (legit delta overlay and phantom union are wire-identical). | §7 P1 rewritten: declared composition = connector-intent ghost provenance per page (verdict class + consult epoch, an honest label of the policy decision that already drives emissions); contractual fold (one replacement per scope per sync, overlays compose only with this-sync replay); attestation = published validator's epoch equals the fold result's epoch. Honesty argument added; §10.5 mutation-adequacy check extended. | +| 3 | MAJOR | Graceful-stop forced checkpoints missing (run-expiry / external cancel force-checkpoint an aborted batch's mid-flight state — hits, spawns, mid-chain cursors); spawn admission timing wrong (same-op spawns drain in the live batch, so pending carriers arise from batch-cap splitting, not batch-end admission). | §3: eStop interruption mode added with forced checkpoint of live state; same-op spawns admitted to the live batch queue (drained in-batch), cross-op spawns to the stack; §9 case 1's pending-carrier premise re-scripted on batch-cap splitting (CO-6b-006's construction). | +| 4 | MAJOR | Replay-blocked flag given op-commit durability the real mechanism lacks (rides ingest-quality state, checkpoint-cadence durable); composition-enum detection modeled store-side/omniscient masks two real windows. | §5 table corrected (checkpoint-cadence durability); §4 deliverable-3 semantics remodeled as syncer-side detection over volatile/checkpointed state (weak variant is the default fix-run configuration); §10.6 obligation extended to detection-state visibility and mark durability. | +| 5 | MAJOR | Produce-side blocking condition broader than contract ("any gate-outcome difference" vs the two real triggers) — over-blocking masks multi-sync propagation. | §3 restated to exactly: (i) compat key recomputed differently across attempts (B4); (ii) attempt without source-cache handling over prior-attempt produce state (CO-6b-003), fail-closed on read error. Consume-side degradation alone never blocks. | +| 6 | MAJOR | P3′ strengthening false for multi-page fetches under mid-attempt mutation (crash-free walks observe multiple instants per scope). | §7 P3′ scoped: checked only in scenarios without mid-attempt mutation; mid-attempt-mutation scenarios rely on P1/P2; per-page refinement noted as future work. | +| 7 | MAJOR | MEnv had no attempt-failure behavior; neither P4 hang shape (deterministic cold re-failure; leaked-lock deadlock) was representable; livelock undetectable in a bounded scenario via raw liveness. | §3 MEnv resume-on-failure rule added; §4 warm-verdict page failure + in-attempt retry added (lock scenario); §7 P4 livelock detection restated as a safety rule (two consecutive resumes failing from identical restored state with identical verdict). | +| 8 | MAJOR | Crash-vs-in-flight race underspecified for multiple outstanding ops (non-prefix-closed committed sets possible); "queue drained" ambiguous. | §5 pinned: eCrash's position in MStore's queue partitions dead-attempt ops — before = committed, after = dropped; per-sender FIFO preserves per-worker prefix closure; quiesce = drop, never process. | +| 9 | MAJOR | Hit-recording semantics unpinned (record-at-lookup-hit regardless of revalidation outcome; last-write-wins; P2's "validated" = upstream match, not lookup hit) — case 3 depends on all three. | §3/§7 pinned with code citations; §9 case 3's "also exhibits with no re-consult" scoped to `hitValidatorBinding` off. | +| 10 | MAJOR | Carrier-less phantom variant missing: copy commits durably mid-batch, crash before checkpoint → durable debris with no durable replayed mark; attempt-2 fresh fetch upserts over it. More reachable than the scripted variant; defeats syncer-side composition detection. | §9 case 1 gains the carrier-less variant as a first-class cell; flagged as the priority trace to compile into a chaos scenario (deliverable 6). | +| 11 | MINOR | §2.1 vs §3.3 disagreement on batch composition as a choice point; cap-shrinking argument implicit. | §3: batch cap nondeterministic ∈ {1..capMax} per iteration; small-scope scaling argument stated (CO-6b-006's 102-action construction is the existence proof). | +| 12 | MINOR | P6-A fired on any later-attempt divergence (d1→d2→d1 false positive). | §7 P6-A compares embedded stamps against the writer's FINAL derived value at seal. | +| 13 | MINOR | Case 1 interleaving B's expected verdict depends on unpinned carrier publish behavior. | §9 splits interleaving B into two cells: carrier publishes V1 → P3′ violation (P1 green); deferred publish → P1 attestation violation. | +| 14 | NOTE | annotationBinding fix run silent on empty-validator replay pages (legal per proto). | §9 case 3 fix run gains an empty-annotation cell; the fix's coverage boundary is a required output of the run. | +| 15 | NOTE | §5 checkpoint-token row understated (ingest quality incl. replay-blocked reason flags is load-bearing for deliverable 3). | §5 table row added. | + +Reviewer's stated residual risk (recorded verbatim in substance): the +composition enum exists only in PR discussion; the model must choose its +durability/detection semantics, and an eventual implementation is not +bound by that choice. The carrier-less phantom trace must be compiled to +a chaos scenario and kept green against the real implementation, or a +model-green "propagation bounded" claim can be true of the model and +false of the shipped mitigation. diff --git a/formal/reviews/model-spec-round2.md b/formal/reviews/model-spec-round2.md new file mode 100644 index 000000000..914c6e46d --- /dev/null +++ b/formal/reviews/model-spec-round2.md @@ -0,0 +1,46 @@ +# Model spec adversarial review — round 2 (of spec v2) + +Reviewer: independent agent (fresh, decorrelated; built its own model +from the 6b contract and code before reading the spec). Verdict: +**REJECT** — 2 blockers, 4 majors, 4 minors, 3 notes. It verified 12 of +the 15 round-1 dispositions as genuinely resolved (1, 4, 5, 7–15) and +confirmed all of v2's code citations and the durability table. Spec +revision v3 addresses every finding; dispositions below. Both blockers +were scenario-REACHABILITY defects — the machine semantics were right, +and the scripts contradicted them — which is why v3 adds the standing +reachability-walk obligation (§2.6, §10.0). + +| # | severity | finding (condensed) | disposition in spec v3 | +|---|---|---|---| +| 1 | BLOCKER | Scenarios 1a/1b and 3 unreachable as scripted: a same-op spawn can never be stranded at a loop-top checkpoint (spawns drain in-batch, `parallel_syncer.go` 656–697), a mid-batch spawn admission is volatile under hard crash, and the pre-pushed-carrier alternative needs connector cross-call state the spec forbids. The reachable premise generator is the graceful-stop forced checkpoint. | §9 re-scripted on the STOP-STRANDING pattern: the stop-forced checkpoint durably captures {parent mid-chain cursor, admitted-but-undrained carrier, hit map} together (checkpointability pinned by `TestSpawnedActionsSurviveCheckpoint`); the attempt-2 re-consult comes from the parent's next page. Verdicts route through page tokens (no cross-call memory); the purity-vs-proto boundary is recorded in §8. Verified against code before adoption. | +| 2 | BLOCKER | Scenario 2's hard-crash cell claimed expected-green; false — session KV is durable, pops are volatile, so both actions re-run, and the G-before-H schedule (a genuine choice point) re-embeds stale d1 → P6-A alarms. Real shipped behavior; freezing the green expectation would force the P code to mask it. | §9 case 2 split into 2-stop (deterministic script) and 2-crash (interleaving-dependent expected FINDING, with the complementary H-first schedule required green). The false parenthetical claim removed. | +| 3 | MAJOR | P1 fold under-specified where it decides alarm-vs-miss: per-page vs per-round granularity, undefined epoch for partially applied delta rounds at publish (plan B5 legally publishes the new token before overlay pages land), deterministic-fold vs existential formulations mixed. | §7 P1 fully pinned: round definition (maximal same-verdict run of one chain's pages), complete-rounds-only deterministic fold in commit order (replacement/overlay/fresh rules; fresh REPLACES in the fold), log-legality rules, content+attestation+config checks at seal, ATTESTATION-ONLY at publish. | +| 4 | MAJOR | P3′ scoping incomplete: a fresh round torn mid-chain by a stop and resumed after between-attempt mutation observes two epochs inside the allowed scenario class → spurious counterexamples contaminating calibration attribution. | §7 P3′ doubly scoped: no mid-attempt mutation AND no torn round for the scope (ghost torn-round flag). 1b-i's P3′ verdict re-checked under the new scoping (its rounds are not torn). | +| 5 | MAJOR | Scenario 3's claimed P2 violation contradicts P2's own pinning: attempt 1's validation match qualifies the scope as consulted this sync, so P2 passes; the actual catch is P1-attestation. Interleaving with attempt 2's fetch-fresh round was underived. | §9 case 3 re-derived per cell: P1 attestation (carrier last) or P1 content (carrier first/interleaved); P2 explicitly GREEN in every cell; 3B (binding-off) premise simplified to the no-re-consult route. | +| 6 | MAJOR | `warmGate` had no killing scenario (all scripted attempts were warm), so §10.5's mutation-adequacy obligation was unsatisfiable; produce trigger 1 also unexercised. | §9 scenario 5 added: 5a compat-drift cell (trigger 1) kills warmGate via the new P1 config clause; 5b capability-withdrawal cell exercises trigger 2 fail-closed. §6 gains an explicit kill-obligation table. | +| 7 | MINOR | G6 (capability) folded into a static "previous artifact usable" boolean, making produce trigger 2 unreachable. | §1/§3: G6 is a per-attempt bit on MEnv's schedule; warm install and trigger 2 consume it; scenario 5b exercises it. | +| 8 | MINOR | §4's replayed-set check missing its `[toggle: oncePerScope]` marker. | Marker added. | +| 9 | MINOR | Glossary "Restart-from-root" and "Checkpoint" entries state the hard-crash rule as universal, contradicting the spec's (correct) stop-path semantics; the glossary is read first. | Both `GLOSSARY.md` entries corrected: forced sites enumerated, stop-checkpoint contents named, restart-from-root scoped to hard crash. | +| 10 | MINOR | C1 had no carrying scenario (no policy places a replay annotation on page ≥ 2), so it would resolve vacuously. | §9 scenario 5 gains the C1 probe: replay annotation on page 2, stop between pages, resume without fresh consult — model answers C1 "reachable via the stop path", recorded as a conformance finding to test through the chaos bridge. | +| 11 | NOTE | Session KV shares MStore's durability domain/crash cut in the model; prod session store is a separate, non-prefix-ordered service. | §8 records the trust boundary of P6-A's verdicts (brief pins variant A durable). | +| 12 | NOTE | "Intent" named both the P1 ghost label and the deliverable-3 wire enum; the ghost exists with `compositionEnum` off. | Ghost renamed "verdict class" throughout; "intent" reserved for the wire enum (§4 states the reservation). | +| 13 | NOTE | Batch-cap argument overclaimed "every split shape"; parts ≥ 3 unexplored; the true justification (in-batch spawn admission is uncapped; multi-way splits decompose into two-way splits) was unstated. | §1 argument rewritten with the honest justification. | + +Residual risks recorded by the reviewer (carried into the calibration +report's obligations): + +1. The composition enum exists only in PR discussion; the 1c trace must + be compiled to a chaos scenario and kept green against the real + implementation, or a model-green "propagation bounded" claim can be + true of the model and false of the shipped mitigation. (Carried + from round 1; §4 and §10.6 keep it explicit.) +2. Cross-attempt fresh-debris unions (no replay involved) are real + shipped behavior adjacent to scenario 1's config; §9 now + pre-commits to classifying out-of-script counterexamples of that + shape as design findings, not model noise. +3. Connector purity under-approximates legal connector behavior + (within-sync memory); extensions are change orders (§8). +4. The pre-seal forced checkpoint site, which the reviewer accepted + from the spec's assertion, was verified directly during disposition: + `syncer.go` 1162 (post-expansion, pre-seal, force=true), alongside + Init (232/268/1115) and stop/expiry (195/469/490). diff --git a/formal/reviews/model-spec-round3.md b/formal/reviews/model-spec-round3.md new file mode 100644 index 000000000..6d19e138a --- /dev/null +++ b/formal/reviews/model-spec-round3.md @@ -0,0 +1,47 @@ +# Model spec adversarial review — round 3 (of spec v3) + +Reviewer: independent agent (fresh, decorrelated; built its own model +from the 6b contract and code before reading the spec). Verdict: +**REJECT** — 1 blocker, 0 majors, 4 minors, 2 notes. Substantial +convergence from round 2: the reviewer mechanically walked ALL 18 §9 +scenario cells (reachability + verdict derivation, applying the P1 fold +by hand) and confirmed 17; it verified 12 of 13 round-2 dispositions as +genuine (the 13th — finding 6 — was half-resolved: the warmGate leg +held, the trigger-2 leg is this round's blocker). Spec revision v4 +addresses every finding; dispositions below. + +| # | severity | finding (condensed) | disposition in spec v4 | +|---|---|---|---| +| F1 | BLOCKER | §4/§9-5b scripted "fail closed: loud attempt failure" for a replay annotation arriving in a capability-withdrawn attempt. Ground truth: B1 ignores every source-cache annotation wholesale when capability is absent (`sourceCachePageOps` returns nil ops when `sourceCacheEnabled()` is false, `source_cache_orchestration.go` 463–468 — verified directly during disposition); the CO-6b-005 capability-withdrawn chaos cell completes GREEN with the artifact replay-blocked; the block fires at install time (CO-6b-003), not page arrival. §3 (install-time) and §4 (page-arrival) also contradicted each other. Frozen as-is: a machine-checked falsehood, and the cell masks the real shipped hazard (silent annotation drop under a green sync). | §4 bullet rewritten to B1 silent-ignore with trigger 2 pinned to install time; §9 5b re-scripted: green seal, cold consults, empty partition for S, artifact blocked — with the SILENT SCOPE DROPOUT promoted to a required design finding whose oracle is the scripted seal-state expectation (see F7). | +| F2 | MINOR | P1 fold order unanchored for page-interleaved rounds (first- vs last-page commit); all scripted logs agree under either anchor, but out-of-script counterexample logs — exactly what §9's pre-committed classification covers — need not. | §7: fold order pinned to ROUND COMPLETION (commit of a round's last page), with the rationale stated. | +| F3 | MINOR | §3 said completed actions pop "at batch end"; in code the pop commits at completion, mid-batch (state commit ~656 precedes queue admission ~667) — and the spec's own 2-stop cell depends on the mid-batch pop. §2.5 violation (correct semantics lived only in the eStop paragraph and the script). | §3 bullet 4 and MWorker corrected: pops commit at completion, mid-batch; the 2-stop dependency is named in place. | +| F4 | MINOR | §5 and the glossary overclaimed "under hard crash the surviving checkpoint contains only root tokens" — false for stop-then-crash, where a stop-forced checkpoint with mid-chain cursors/spawns survives a later hard crash. | §5 resume paragraph and the glossary entry restated: restart-from-root is a property of WHICH checkpoint survives (crash-only histories), not of the crash itself. | +| F5 | MINOR | Spawn dedup modeled only on cross-op stack pushes; code applies the spawnedAdmitted guard to ALL spawned admissions plus commit-local duplicate-cursor rejection. Without it, legal connector re-mentions produce spurious P4 livelock counterexamples. | §3 bullet 4: dedup extended to all admissions (re-mentions skipped, not errors) plus the commit-local loud rejection; dedup index volatility unchanged. | +| F6 | NOTE | Stop-stranding window stated too narrowly ("before a worker dequeues"); any stop before the carrier's first atomic step completes qualifies. Documentation-only (the scripted route was reachable). | §9 preamble widened. | +| F7 | NOTE | Even corrected, 5b has a shape invisible to P1 (vacuously green — no legal round) and P2 (quantifies over rows present): the carrier's scope rows silently missing from a green seal. | Folded into the 5b re-script: the dropout is the cell's required design finding, checked by the scripted seal-state oracle; a general completeness/coverage oracle is recorded as a deliverable-6 chaos-bridge question. | + +§9 cells walked and confirmed by the reviewer (reachability + verdict): +1a, 1b-i, 1b-ii, 1c, the 1-fix cells including the crash-window +variant, 2-stop, 2-crash (both schedules — the G-first alarm and the +required-green H-first), 3A (both interleavings), 3B, the 3-fix cells +including empty-validator, 4 (locks off and on), 5a (including the +warmGate-off mutant kill via the P1 config clause), the C1 probe +(checkpoint token carries `sourceCacheHits` per `state.go` Marshal, so +the restored hit map passes the SDK hit check — C1 is genuinely +reachable via the stop path). 5b was walked and refuted (F1). + +Residual risks recorded by the reviewer (carried into the calibration +report's obligations): + +1. The 1c compositionEnum trace must be compiled to a chaos scenario + and kept green against the real implementation (carried from rounds + 1–2). +2. The fold-anchor pin (F2) matters precisely on out-of-script + counterexample logs; keep it in view when classifying them. +3. Connector purity under-approximates legal within-sync connector + memory (carried; §8 records it). +4. The silent-missing-rows shape behind 5b is invisible to P1/P2 by + construction; the scripted seal-state oracle covers the calibration + cell, and the general question is a deliverable-6 obligation. +5. The empty-validator vacuous-binding residual from the scenario-3 fix + runs remains open by design. diff --git a/formal/reviews/model-spec-round4.md b/formal/reviews/model-spec-round4.md new file mode 100644 index 000000000..257c68b15 --- /dev/null +++ b/formal/reviews/model-spec-round4.md @@ -0,0 +1,56 @@ +# Model spec adversarial review — round 4 (of spec v4) + +Reviewer: independent agent (fresh, decorrelated; built its own model +from the 6b contract and code before reading the spec). Verdict: +**REJECT — 0 blockers, 0 majors, 3 minors, 3 notes**, with the explicit +disposition that all three minors are fix-without-re-review: "land the +three edits and freeze; no further full round is warranted." All seven +round-3 dispositions were verified as genuinely resolved against ground +truth (not just present); the corrected 5b cell was walked end to end +against code and the CO-6b-005 chaos cell; the fold was re-applied by +hand across 1a/1b-i/1b-ii/1c/3A/3B/4; every cited line number and test +pin was confirmed to exist. Spec revision v5 applies all six findings; +dispositions below. + +| # | severity | finding (condensed) | disposition in spec v5 | +|---|---|---|---| +| 1 | MINOR | v4's own dedup extension (F5) made cell 4's "duplicate replay carriers" premise unreachable as written: byte-identical duplicates are rejected commit-locally within one transition or skipped by the spawnedAdmitted guard across transitions. The realized ground-truth shape (CO-6b-003/005 chaos instruments) uses pages from DIFFERENT resources targeting one scope — distinct identity digests. | §9 cell 4 premise pinned: byte-distinct page tokens encoding the same (scope, verdict); literal duplicates explicitly noted as unable to produce the premise. | +| 2 | MINOR | P1's strict overlay precondition (fold value must equal rows(e_from)) alarms on cell 4's scripted GREEN locks-on run: B5 legally copy-skips the duplicate replay and applies its upserts normally, making the second overlay round's precondition unsatisfiable — the fold ambiguity F2 was meant to kill, surviving in the passage F2 edited. | §7 fold gains the duplicate-tolerance clause: a copy-skipped overlay round folds as a NO-OP when the fold value already equals rows(e_to); replacement-count legality counts COMMITTED copies, not verdict labels (locks-off's two committed copies alarm; locks-on's copy-skip folds green). | +| 3 | MINOR | "Produce-side blocking — exactly two triggers, nothing broader" is false of the system: page-arrival shape guards (child-resource declarations, `InsertResourceGrants`), ingest-filter drops (B6), and unknown-prior-checkpoint conservatism also block. None are reachable in the model, so no cell verdict was wrong — but frozen as a fidelity statement it is a falsehood readers and model extensions inherit. | §3 scoped to "within the modeled fragment" with the excluded triggers named; §1's abstraction list registers them with the reason each is unreachable in the model. | +| 4 | NOTE | 5b's "matching the CO-6b-005 chaos cell" over-attributed: the chaos cell pins green completion, cold consults, compat retention, and the blocked mark — NOT the empty-partition dropout (its connector adapts cold on miss; no stranded carrier exists there). | §9 5b narrowed: the four pinned outcomes attributed to the chaos cell; the dropout attributed solely to the model's scripted seal-state oracle. | +| 5 | NOTE | "Loop-top checkpoints contain only root tokens" is true of the modeled (batched) population only; sequential non-fanned ops (e.g. `SyncResourceTypesOp`) can checkpoint mid-chain at loop tops in crash-only histories. | §8 boundary note added; future scenarios touching sequential ops must not inherit the claim. | +| 6 | NOTE | The commit-local duplicate-cursor rejection is same-op-scoped in code (`queue.transition` checks only children with the batch op); §3 stated it unqualified. | §3 qualifier added. | + +Verification coverage reported by the reviewer: round-3 dispositions +F1–F6 + §11 all verified genuine (F1 against `sourceCachePageOps` +463–468, the proto's capability wording, `installSourceCacheLookup`'s +install-time block, and `Checkpoint`'s `SetIngestQuality` durability; +F4 against the derived stop-then-crash ground truth). Cells re-walked +by hand: 1a, 1b-i, 1b-ii, 1c (+ fix-run claim boundaries), 2-stop, +2-crash (both schedules), 3A (both interleavings), 3B, 4 (all +togglings — findings 1 and 2 live here), 5a (both togglings), 5b (end +to end), C1 probe. Freeze sweep: §5 table vs `state.go` +Marshal/Unmarshal (warm flag genuinely absent from the token), §6 kill +table vs cells, §7 vocabulary vs events, §11 vs all round logs, +glossary vs spec and code. + +Residual risks recorded by the reviewer (carried into the freeze +record and the calibration report's obligations): + +1. No v3/v4 baseline exists to diff — `formal/` is untracked, so the + "surgical delta" claims were verified by re-walking, not + mechanically. COMMIT THE SPEC AT FREEZE so change orders have a + diffable baseline. +2. The composition enum's semantics exist only in PR discussion and + could not be verified against any repo artifact; the spec labels + this an input assumption (§4). Confirm before deliverable 3's runs; + keep the 1c trace compiled to a chaos scenario (carried from rounds + 1–3). +3. The silent-dropout shape behind 5b has no chaos-suite analogue; the + deliverable-6 completeness-oracle question is the only path to an + executable check. +4. Carried: fold-anchor discipline on out-of-script logs (now with + finding 2's clause), connector-purity under-approximation, the + empty-validator vacuous-binding residual in the scenario-3 fix runs. +5. Finding 5's boundary: future scenarios touching sequential ops must + not inherit the batched-population checkpoint claim. diff --git a/formal/reviews/model-spec-round5-addenda.md b/formal/reviews/model-spec-round5-addenda.md new file mode 100644 index 000000000..42007b591 --- /dev/null +++ b/formal/reviews/model-spec-round5-addenda.md @@ -0,0 +1,84 @@ +# Round 5 — targeted spot review of the v6 signoff-discussion addenda + +Scope: §9 cell 1d, §9 scenario 6 (collect-and-commit variant pair), +§7 fold-totality clauses (self-grounding overlay rounds, copy-skipped +replacement rounds), §10.5 update — per the §11 v6 change-order entry. +Not a fifth full round; v1–v5 material was out of scope except where +the addenda destabilize it. + +Method: mechanical reachability walk of each new premise under +§3/§4/§5; hand-application of the extended §7 fold over every schedule +class each cell can produce; coherence sweep against rounds 3–4; +verification of the copy-skip publish and validator-less replay +citations against `pkg/sync/source_cache_orchestration.go` and plan B5. + +Verdict: **REJECT — 2 majors (F1, F2) + 6 minors, ALL +fix-without-re-review** per the round-4 convention; no further round +warranted. Positive results: all three premises reachable without +hand-placement; the extended fold is total and deterministic over +every addenda log once F1's pin lands; 1d's +content-green-every-schedule claim survived adversarial schedule +construction under shipped toggles; no contradictions with the +round-3/round-4 dispositions. + +Findings and dispositions (all applied as v7): + +- **F1 (MAJOR)**: "round completion — the commit of a round's last + page" never defined page COMMIT; store-op vs scheduler-transition + readings diverge for the first time on 6-atomic's verdict (unit + committed, transition lost, re-execution marker-suppressed → + ops-reading green as scripted, transition-reading false-alarms). + → §7 pins: a page commits when the last of its prescribed STORE ops + commits (announce-visible); transitions/pops are not fold events; + no-store-op rounds contribute no fold entry. Scenario 6 pins the + variant-specific consequences (V-ATOMIC round complete at + `eReplayUnit` commit; V-NAIVE's marker op is a prescribed round op). +- **F2 (MAJOR)**: 1d attributed the same-base-copy collapse to + `oncePerScope` alone and called it "structural"; the check-then-mark + collapse is atomic only under `scopeLocks` (case 4's dual-replay + TOCTOU — a locks-off 1d schedule is content-red, walked concretely). + → re-attributed to `oncePerScope` ∧ `scopeLocks`, "structural" + demoted to mitigation-dependent, locks-off 1d mutant added to §10.5. +- **F3 (minor)**: validator-less-C sub-case mis-scripted — whether C's + copy commits is schedule-dependent, not a property of + validator-lessness (C-first commits; verdict green either way). + → re-scripted per schedule class, aligned with §7's no-op vocabulary. +- **F4 (minor)**: 1d left V2's publish placement unpinned, so the + green/alarm schedule partition wasn't enumerable (B5 early publish + makes publish order ≠ drain order). → both placements pinned as + explored sub-configs; partition stated per sub-config. +- **F5 (minor)**: the §7 torn-round boundary justification argued only + from stop-consumption; scenario 6 is crash-based. → extended: + crash-only histories resume from root-token checkpoints, cannot + tear; incomplete-round debris named in the fold text (6-naive rests + on it). +- **F6 (minor)**: V-ATOMIC under-specified its relationship to the §5 + checkpoint token; "hit durability can never precede materialization" + was false for the still-checkpointed hit map (true of the marker). + → pinned: token unchanged, restored hits never authorize without a + consult, stranded hits inert, clause (iii) applies to both variants; + wording corrected to durable consult PROVENANCE (the marker). +- **F7 (minor)**: §11 over-scoped 6-atomic's green claim to "the + case-1 family", which now contains 1d, whose overlay flavor V-ATOMIC + doesn't define (stale-AHEAD hazard of marker-before-overlay). + → de-scoped to the 1a/1b/1c re-runs; overlay-flavor unit semantics + declared an explicit deliverable-4 obligation. +- **F8 (minor)**: §7 P2's consult pin (validation match or fresh + fetch) excluded 1d's changed-with-diff verdict, making P2 alarm + every 1d schedule unscripted. → pin extended (revalidation occurred + and the diff is an upstream fetch); 1d's P2 expectation stated + (green, staleness ≤ 1). + +Notes to the freeze record: **N1** partial-copy debris renamed to +avoid colliding with §7's cross-attempt TORN. **N2** the +self-grounding clause retroactively closes a latent v5 fold-totality +gap (case 4's locks-on surviving round satisfied no v5 clause); +round-4's fold-walk coherence is now documented rather than +accidental. **N3** the 1d flavor-coverage note (delta connectors +degrade to fetch-fresh on token expiry) labeled external-boundary +commentary — a connector-population claim outside the model. **N4** +V-ATOMIC's marker-check-before-consult sits outside the scope lock — +a check-then-act window that two concurrent consulting actions for +one scope would race (two committed copies → P1 legality alarm); +unreachable in the scripted family, recorded as a 2-worker hazard for +the deliverable-4 bake-off boundary notes. diff --git a/formal/reviews/model-spec-round6-scenario7.md b/formal/reviews/model-spec-round6-scenario7.md new file mode 100644 index 000000000..518882e3d --- /dev/null +++ b/formal/reviews/model-spec-round6-scenario7.md @@ -0,0 +1,91 @@ +# Round 6 — targeted spot review of the v8 addendum (scenario 7) + +Scope: §9 scenario 7 (cells 7a/7b/7c + fix runs), §7 P6-R, §8 +counterfactual-ghost note, §6 `sessionTaintWrites`/`sessionTaintAll` + +kill obligations, §10.5 additions, glossary entries "Elision" and +"Session taint" — per the §11 v8 change-order entry. Not a full round; +v1–v7 material out of scope except where the addendum destabilizes it. + +Method: mechanical reachability walk of all cells and fix runs under +§3/§4/§5; hand-application of the fold (round-5 F1 pin), P2, P3′, +P6-A, and P6-R over every schedule the cells produce; coherence sweep +against rounds 3–5; verification of every shipped-system claim against +`source_cache_orchestration.go`, `session.proto`, `sessions.go`, +`pebble/session_store.go`, `session_server.go`, and the 6b plan. + +Verdict: **REJECT — 4 majors + 5 minors + 3 notes, ALL +fix-without-re-review**; no round 7 warranted. Verified clean: all six +shipped-system claims true (no sessions × source-cache coupling; +sync_id-scoped namespaces; ungated session RPC during listings); every +cell and fix-run verdict re-derives as scripted under the recoverable +readings; 7c's green is entailed by policy purity, not assumed; +round-5 F1 and the torn-round boundary undisturbed; kill tables +internally consistent; "R violates no pinned obligation" consistent +with the verdict-as-data and trust-boundary framing. + +Findings and dispositions (all applied as v9): + +- **F1 (MAJOR)**: scenario 7 silently widened §1's one-row-kind + abstraction — two kinds require two OPS for the sequential-phase + premise (same-op W/R would batch together and interleave), plus + per-kind produce/consume state, none declared. → KIND axis declared + in §1 as an (op, scope) pair riding on an unchanged storage row-kind + axis; small-scope table row added (2 kinds in scenario 7 only); §8 + note updated; taint state scoped by the axis. +- **F2 (MAJOR)**: P6-R's stamp-travel extension put traveled stamps + inside P6-A's quantification domain, where two readings diverge on + 7b and the ⊥ stamp is ill-typed. → P6-A domain pinned: only stamps + embedded by reads within the sealing sync; traveled and ⊥ stamps + belong to P6-R; P6-A vacuously green on 7a/7b/7c. +- **F3 (MAJOR)**: taint durability unstated (5b/CO-6b-003 precedent + requires pinning); the volatile-until-seal reading silently breaks + the 7a kill obligation in interrupted histories. → pinned + checkpoint-cadence (ingest-quality-style) in §5 and §6, with the + self-healing argument (re-execution re-records) claimed explicitly — + stronger than `compositionEnum`'s detection-evidence story. +- **F4 (MAJOR)**: "replay-capable kind's phase" ambiguous; the + warm-install reading makes the 7a fix run unsatisfiable (sync N is + cold, so no taint would record). → pinned: flow membership, + independent of the recording attempt's warm/cold state; fix-run text + states the taint records in a cold attempt by design. +- **F5 (minor)**: consume-side enforcement unspecified and "runs W + cold" collides with §4's loud COLD verdict. → §3 `eLookup` extended + (tainted kind → miss; degradation, never loud); §9.7 wording + clarified. +- **F6 (minor)**: §7's P6-R scoping ("no mid-attempt mutation") + admitted between-attempt mutation §8 declares unsound. → aligned to + between-sync-only (single epoch per (sync, scope) per sync). +- **F7 (minor)**: counterfactual unpinned for multi-write producers; + reader-timing independence implied, not stated. → pinned as the + producer's phase-final value under empty-namespace evaluation; + no-cross-op-spawn config constraint and timing independence stated. +- **F8 (minor)**: "divergent rows" cannot diverge in content under + §3 (policies never choose content); ghost-only divergence forced but + unstated. → stated in 7a plus a §8 under-approximation note (the + real system has no content oracle for fresh rounds either — the + finding survives the abstraction). +- **F9 (minor)**: 7a's "kind outside the replay flow" premise route + is unmodeled. → struck; route pinned to "policy fetches fresh." +- **F10 (NOTE)**: shipped session surface includes + Delete/DeleteMany/Clear; model reaches Get/Set only, newly + load-bearing for the taint definition. → registered in §1; §6 WRITE + defined as any mutating op. +- **F11 (NOTE)**: fix runs re-execute the full two-sync script with + the toggle ON (first produce-side toggle family — acts a sync before + the red verdict); was implied only. → stated in §9.7. +- **F12 (NOTE)**: §3's `eCopyScope` ghost tuple lacked the embedded + session stamp P6-R requires to travel. → extended: lineage fields + added, embedded stamps copied unchanged. + +Also applied in the same v9 revision (signoff-discussion items, not +review findings): the capability-level OPT-OUT (attested +emission-irrelevance; a dishonest opt-out reproduces 7a/7b exactly) +and the out-of-model enforcement layers (static analyzer, pre-release +`SessionStoreUsage` conformance assert, runtime taint — one detector, +three timings). + +Process observation (from the review, for the freeze record): v6 and +v8 share a pattern — new machinery arriving through scenario scripts +rather than through §1/§3/§5 first. Scenario cells were sound both +times; the undeclared machinery beneath them was where all four majors +lived. diff --git a/formal/reviews/model-spec-round7-overlay-parallel.md b/formal/reviews/model-spec-round7-overlay-parallel.md new file mode 100644 index 000000000..2d807dd93 --- /dev/null +++ b/formal/reviews/model-spec-round7-overlay-parallel.md @@ -0,0 +1,332 @@ +# Round 7 (parallel) — second independent spot review of the v10 addendum + +PROVENANCE NOTE: two independent round-7 spot reviews of the v10 +addendum were run in parallel; this is the second, surfaced after the +primary (`model-spec-round7-overlay.md`) had been dispositioned as +v11 and the spec frozen. Its findings are dispositioned as MS-CO-001 +(see MODEL_SPEC §11): the overlapping findings (its F1 ≈ primary F3, +F2 ≈ primary F4, F3 ⊂ primary F5) were already fixed in v11; the +non-overlapping items (F4, F5, F6, N1, N4) are applied by the change +order. Its "third-placement reduction: sound" verdict DISAGREES with +the primary's F2 (false reduction); the built cell `tc6overlayLast_P1` +settles the disagreement mechanically in the primary's favor — see the +MS-CO-001 entry. Text below is the review verbatim. + +--- + +Scope: §9.6 V-OVERLAY-UNIT declaration (pins o-i..o-iv), cells +6-overlay and 6-overlay-naive, the §5 overlay-collect-buffer row, the +rewritten scenario-6 pilot-scope paragraph, the 1d cross-reference +sentence, the §10.5 obligation extensions, and the §11 v10 entry — per +the §11 v10 change-order entry. Not a full round; v1–v9 material out of +scope except where the addendum destabilizes it. + +Method: mechanical reachability walk of 6-overlay sub-cases (a)–(d) and +6-overlay-naive under §3/§4/§5 as modified by o-i..o-iv (crash position +in MStore's queue per the §5 prefix rule, stop-checkpoint contents, +o-iv resume behavior, clause-(iii) suppression); hand-application of +§7's fold (round-5 F1 completion pin, self-grounding-overlay and +copy-skipped clauses), P2 (changed-with-diff consult pin), and P3′ over +every schedule the cells produce; adversarial schedule construction +against the toggles-off green claim; coherence sweep against rounds 3–6 +and against 6-atomic, 1d, 5b, and the round-5 F7 disposition; +verification of the wire-contract and walker-mechanics claims against +`docs/verification/sync-replay-6b/plan.md` (B1–B10, CO-6b-001..007), +`proto/c1/connector/v2/annotation_source_cache.proto`, +`pkg/sync/source_cache_orchestration.go`, `pkg/sync/state.go`, +`pkg/sync/parallel_syncer.go`, and +`pkg/dotc1z/engine/pebble/source_cache.go`. + +Verdict: **REJECT — 1 major (F1) + 5 minors + 4 notes, ALL +fix-without-re-review** per the rounds 4–6 convention (every +disposition is a pin or declaration; no scripted cell verdict changes +under the intended readings; no re-script). No round 8 warranted. + +## Verified clean (for the freeze record) + +- **Reachability.** All 6-overlay sub-cases (a)–(d) and + 6-overlay-naive's premise walk mechanically without hand-placement. + 6-overlay-naive's crash lands between `eOverlayUnit'` and the final + page's `eUpsertPage` in one sender's FIFO stream — a genuine + queue-position choice under §5's prefix rule, the same mechanism + 6-naive uses; restart-from-root holds (crash-only history, Init + checkpoint survives, checkpoint-skip nondet at the sole loop top). + Sub-case (b)'s stop-checkpoint contents (mid-chain cursor + hit + {S: V1}, buffer lost) follow §3's stop semantics exactly; the + restored hit is inert per the carried-over V-ATOMIC pin; + clause-(iii) suppression in naive's attempt 2 is the declared marker + semantics, not scenario hand-placement. Budgets hold: ≤ 2 syncs, + ≤ 2 attempts per sync, 1 crash or 1 stop per sub-case, buffer + bounded by the 2-page round. +- **Fold coherence for 6-overlay.** The unit's round folds as §7's + EXISTING self-grounding-overlay clause with no new fold clause — own + copy committed inside the unit, folds to rows(s, e_to), copy counts + toward replacement legality (exactly one unit per scope per sync is + constructible in the family: one chain, marker suppresses + re-execution, crash cannot split the atomic op). Round completion = + unit commit is consistent with the round-5 F1 pin (every prescribed + store op of every page commits at the unit's queue position; + announce in prescribed page order keeps the fold order + well-defined). Sub-case (b)'s attempt-1 fragment commits no store + ops and contributes no fold entry (existing pin); no torn round is + constructible — P3′'s by-construction claim holds, and its (i) + scoping holds (mutation is between syncs only). +- **6-overlay-naive's incompleteness.** Under the F1 pin, the round's + prescribed store ops are the unit' constituents PLUS each overlay + page's upserts/tombstones; the final page's ops never commit, the + round is INCOMPLETE (not torn — all committed pages sit in attempt + 1), and marker suppression prevents any attempt-2 round. The + committed prefix is debris. The publish-time check is + attestation-only and green (V2's epoch equals the verdict epoch e2), + so the alarm correctly lands at seal — modulo finding F1 below on + what the seal checks are defined to compare against. +- **Toggles-off claim.** With `oncePerScope` AND `scopeLocks` both + OFF, every schedule the scripted family allows was walked: the + single consulting chain is the only actor on S (o-i removes the + carrier; whole-chain worker ownership per §3), so no interleaving + exists for a lock to serialize — the family does not secretly depend + on one. `oncePerScope`'s function is genuinely subsumed by the + in-unit marker (at most one unit per scope per sync in every + constructible history). The two-worker marker-race boundary note is + honestly scoped: the dual-consult shape is unreachable in the + single-chain family and stays a recorded hazard, correctly carried + over from round-5 N4. +- **P2/P3′.** 6-overlay's P2 green follows from the round-5 F8 + changed-with-diff pin (staleness ≤ 1: base rows one hop, overlay + rows fresh). 6-overlay-naive's verification-sync claim follows from + P2's pinned definitions: the mosaic's V2 entry revalidates clean + (truthful validators, upstream fixed at e2), the per-seal consult + check stays green, and the staleness corollary exhibits growth to + the chain bound on the replayed stale rows — the same "unbounded + branch" convention as case 1 (wording caveat in N2). The stale-AHEAD + non-self-healing classification is correct: a future consult of V2 + delivers diffs from e2 onward only; the e1→e2 changes are never + re-delivered — the genuine dual of 1d's stale-BEHIND. +- **Wire-contract claim (o-iii).** TRUE as stated, verified against + the proto and the orchestration code: + `SourceCacheReplay.cache_validator` documents both token placements + (replay page, or deferred to the final record page's + `cache_validator`); the manifest write timing is runtime-internal + and unobservable on the wire within a sync — the warm lookup and the + ask/answer continuation resolve against the PREVIOUS artifact only + (`previousSyncSourceCacheLookup.prev`; the proto's continuation + diagram). B5's early publish is a permission, not an obligation, so + declining it is a runtime design restriction, exactly as the pin + says. (Two adjacent looseness items: F2, F3.) +- **Third-placement reduction.** "Per-page commits with marker+publish + LAST outside any unit reduces to 6-naive's unmarked-debris class" is + sound: under a changed-with-diff re-verdict the next attempt's own + clear/copy replaces the debris; the debris is harmful only under a + fetch-fresh follow-up, which is exactly 6-naive's scripted kill. No + separate cell needed. (An adjacent legality-counting boundary is + recorded as N3.) + [MS-CO-001 NOTE: overturned mechanically — see the provenance note.] +- **No destabilization.** 6-atomic's green claim stays de-scoped to + the 1a/1b/1c re-runs; 1d's verdicts are untouched and its new + cross-reference sentence is accurate; the round-5 F7 disposition is + correctly historicized (the §11 v7 entry is unmodified, append-only + discipline kept; the v10 entry states the supersession); the + rewritten pilot-scope paragraph names exactly the two obligations + round 5 F7 deferred (the unit's publish for a diff verdict; the + marker-before-overlay stale-AHEAD hazard) — verified against the + round-5 record. §5's crash-wipe column stays consistent with the new + buffer row; the announce-at-commit story keeps the §2.4 monitor + subscription implementable; the o-iv/§5 relationship is coherent + (restore-as-is governs checkpoint restoration, o-iv governs + dispatch, and the §5 buffer row cross-references the rule); + conformance question C1 is a shipped-design probe and is untouched. + +## Findings and dispositions + +- **F1 (MAJOR) — the P1 seal checks are undefined over a log with ZERO + complete rounds for a non-empty, attested scope, and the two live + readings flip 6-overlay-naive's verdict.** Spec text at issue: §7's + content check ("partition equals the fold result") and attestation + check ("the manifest entry's epoch … equals the fold result's + epoch"), versus the 6-overlay-naive script ("the round is INCOMPLETE + … contributes no fold entry; the committed prefix is debris → P1 + content violation at seal (and attestation: entry e2 over an + e1-mosaic partition)"). Reasoning: every prior cell's seal log + contains at least one complete round per attested scope — 6-naive + and 1c have the attempt-2 fresh round; the fold's value over an + EMPTY round set is never pinned, and neither is the attestation + comparison when the fold result carries no epoch. Worse, the spec + itself contains the opposing precedent: 5b pins "invisible to P1 (no + legal round for S — vacuously green)." An implementer following 5b's + vacuous-domain reading returns GREEN on 6-overlay-naive's content + check (no complete round → scope outside the check's domain), + contradicting the scripted RED; the empty-fold reading (fold(∅ + rounds) = empty partition → mosaic ≠ ∅ → RED) gives the scripted + verdict. This is precisely the round-5 F1 divergence class: a + definitional gap two honest readings disagree on, surfacing for the + first time on the new cell. The attestation parenthetical is doubly + underdetermined (no fold epoch to compare V2 against). Disposition: + pin in §7 — (a) the fold over zero complete rounds yields the EMPTY + partition (initial fold value = ∅, stated once); (b) a + validator-bearing manifest entry for a scope whose fold result + carries no epoch is an ATTESTATION violation (the entry attests an + epoch the fold cannot ground). Note that this pin RECONCILES 5b + rather than disturbing it: 5b's partition is empty and it publishes + no entry, so it is green by empty-equality and attestation vacuity — + adjust 5b's "vacuously green" parenthetical to say so. State + explicitly that 6-naive and 1c are unaffected (complete rounds + exist). **Fix-without-re-review**: both scripted verdicts hold as + written under the pin; the disposition is a fold pin, not a + re-script. [MS-CO-001: already applied in v11 — primary F3.] + +- **F2 (MINOR) — `eOverlayUnit`'s contents are not total over + wire-legal validator-less rounds.** Spec text at issue: o-ii/o-iii + declare the unit as "{clear, copy(base e_from), overlay + upserts/tombstones …, marker, publish(V_to)}" with publish an + unconditional constituent. Reasoning: B5 legalizes a replayed round + that never supplies a validator ("no entry … a miss next sync — the + replay itself remains valid"), and 1d's validator-less-C sub-case + (round-5 F3) leaned on exactly this legality. Under the variant, a + validator-less changed-with-diff round has no V_to; the declaration + does not say what the unit then contains, so the variant's semantics + are undefined over a legal wire shape. No scripted cell reaches it + (the family always carries V2). Disposition: pin publish-when-present + — the unit omits the publish constituent when the round supplies no + validator; the scope gets no entry and is a miss next sync, the + replay/overlay contents remain valid (B5's own language) — or + explicitly declare validator-less rounds outside the pilot's scope. + **Fix-without-re-review** (declaration pin, no verdict changes). + [MS-CO-001: already applied in v11 — primary F4.] + +- **F3 (MINOR) — the 1d publish-placement sub-config axis silently + collapses in the re-scripted family, and o-iii's parenthetical + asserts one wire shape where the proto permits two.** Spec text at + issue: o-iii's "the connector still returns the token on the replay + page"; the 6-overlay family text, which never mentions the placement + axis that round-5 F4 required 1d to pin as two explored sub-configs. + Reasoning: the proto permits the new token on the replay page OR + deferred to the final overlay page's + `SourceCacheRecord.cache_validator`. Under the variant both + placements feed the same buffered collection and the same unit + publish, so the axis is degenerate — but a family presented as "the + re-scripted 1d premise family" that silently drops a pinned explored + axis invites the round-5 F4 question all over again, and the + parenthetical as written is factually over-narrow. Disposition: one + sentence in o-iii or the 6-overlay cell — both B5 token placements + are wire-legal and collapse to the single unit publish under + o-ii/o-iii; the 1d sub-config axis is degenerate by construction. + **Fix-without-re-review.** [MS-CO-001: subsumed by v11's F5 + rewording; degeneracy noted in the change-order entry.] + +- **F4 (MINOR) — o-iv's cursor-ignoring rule is phrased per-scope but + the restartable unit is the ACTION; multi-scope chains leave the + operational rule undefined.** Spec text at issue: "mid-chain cursors + for unit-mode scopes are restored but IGNORED … resume restarts the + scope's work FROM CONSULT." Reasoning: an action has one cursor, not + one per scope. The model's state space contains planning chains that + consult k scopes (§3 MWorker) and 2-scope configs; a stop-checkpoint + of a chain whose page 1 committed scope S1's unit and whose page 2 + consults S2 restores ONE cursor — "ignore it for unit-mode scopes" + does not say what the scheduler dispatches. The scripted cells are + single-scope, so no verdict diverges, but the pin as declared is not + implementable as written. Disposition: pin o-iv operationally — + under the variant, a restored mid-chain cursor for an action + carrying unit-mode scope work is discarded and the action restarts + from its ROOT token; clause-(iii) marker suppression provides + per-scope idempotence for already-committed units (the at-least-once + re-fetch price already stated). Alternatively restrict the variant + to single-scope chains by declaration. **Fix-without-re-review.** + [MS-CO-001: v11's transition-deferral pin (primary F1) dissolved the + ignore-rule; deferral now explicitly scoped per verdict.] + +- **F5 (MINOR) — the variant's atomic store op is not registered in + §3's MStore op list, and §4 carries no pointer to the variant + override; the round-6 process lesson is only partially complied + with.** Spec text at issue: §3's MStore atomic-op enumeration + (eCheckpoint … eSeal), which contains neither `eOverlayUnit` nor + V-ATOMIC's `eReplayUnit`; §4, whose page-op sequence the variants + supersede for unit-mode scopes with no cross-reference. Reasoning: + the round-6 lesson — new machinery arrives through §1/§3/§5 + declarations, not scenario scripts — is the standing hunt pattern + for this review. v10 complied at §5 (buffer row) and by declaring + pins before cells, but a new MStore atomic op is §3 machinery: §5's + crash protocol ("eCrash is enqueued … like any op") and §2.1's + cross-sender arrival-order choice point quantify over the store-op + vocabulary, which a reader assembles from §3. The semantics are + fully pinned in §9.6, so no two readings diverge — hence minor, not + major — but the registration gap is real, and `eReplayUnit` was + grandfathered only because round 5 predates the lesson. Disposition: + add both variant ops to §3's MStore list, marked scenario-local + (§9.6), and add one line to §4 noting that scenario 6's design + variants replace this sequence for unit-mode scopes. + **Fix-without-re-review.** [MS-CO-001: applied.] + +- **F6 (MINOR) — §10.5 carries no mutation obligation for o-iv, the + one load-bearing line the overlay flavor adds beyond V-ATOMIC's + two.** Spec text at issue: §10.5's new 6-overlay/6-overlay-naive + obligations, which pin the unit boundary (naive red) and the + toggles-off green, but nothing kills a resume that honors the + restored mid-chain cursor. Reasoning: the pair pins "unit contents" + and "marker suppresses re-execution" (scenario 6's own framing); the + overlay flavor newly introduces the buffer-loss resume rule, and its + kill is constructible — in sub-case (b)'s schedule, a + continuation-without-buffer mutant collects only page 2 and commits + a unit missing page 1's overlay ops → partition ≠ rows(e2) under the + self-grounding fold → content-RED. Round-5 F2 set the precedent (the + locks-off 1d mutant was added to §10.5 for exactly this reason). + Disposition: add to §10.5 — an o-iv-removal mutant (resume continues + the restored cursor for a unit-mode scope) is content-RED in + 6-overlay sub-case (b)'s schedule. **Fix-without-re-review.** + [MS-CO-001: applied, and built as a model cell.] + +## Notes to the freeze record + +- **N1.** The marker's durability (per-scope store row, durable at op + commit) is declared only inside §9.6's V-ATOMIC paragraph, while + §2.2 keys mechanical crash-wipe enforcement to §5's table. v10 added + a §5 row for the buffer but not for the marker, which + 6-overlay-naive's premise newly leans on (the marker must survive + the exact crash that drops the overlay upserts). Grandfathered from + v6, but a variant-scoped §5 line ("replay/overlay unit marker | + MStore | durable at op commit — §9.6 variants only") would make the + table total. Cosmetic-plus; fold into the F5 edit. [MS-CO-001: + applied.] +- **N2.** "P2 staleness grows without bound on the never-landed rows" + is imprecise: staleness grows on the PRESENT mosaic rows whose + e1→e2 updates never landed; rows the lost final page would have + ADDED are absent and outside P2's row quantification entirely (the + 5b dropout class — their only oracle is the content check). Reword + so the two halves of the non-self-healing story (present-stale rows + with growing counters; absent rows invisible to P2) are stated + separately. [MS-CO-001: already applied in v11 — primary F7.] +- **N3.** §7's replacement legality "counts COMMITTED copies, not + verdict labels" does not say whether copies belonging to INCOMPLETE + rounds count. No §9 config reaches the shipped-benign shape (B5: a + checkpoint cut between lookup and page commit "re-runs an idempotent + copy" — copy commits, crash loses the replayed set, resume replays + the same scope again), so no scripted verdict is affected; but under + the all-committed reading that shipped-legal schedule would + false-alarm. Record as a config-widening tripwire in the + torn-round-boundary style: any future config scheduling a replay + verdict on both sides of a crash for one scope requires a + legality-count scoping decision (complete-rounds-only vs + all-committed) by change order first. [MS-CO-001: superseded — v11 + pinned complete-rounds-only counting (primary F2) and the + 6-overlay-last cell reaches the shape this note called unreached.] +- **N4.** "Collects the 2-page overlay inline" should be pinned as the + 2-page ROUND (the replay/first-overlay page plus the final overlay + page). The 3-page reading (consult page + 2 overlay pages) violates + §1's pages-per-scope-per-round ≤ 2 bound; 6-overlay-naive's own + premise confirms the 2-page reading (unit' at page 1's consult + boundary, page 1's upserts committed, page 2's dropped). One clause + fixes it. [MS-CO-001: applied.] + +## Process observation + +v10 is the first addendum that visibly internalized the round-6 lesson +— the pins precede the cells, the buffer reached §5, and the cells +cite the fold clauses they rely on — and it shows: the cells +themselves walked clean, and the one major lives in §7's check +definitions rather than in undeclared scenario machinery. The residual +pattern is narrower than round 6's: machinery declared in the right +ORDER but not in all the right PLACES (F5, N1), and a property-layer +totality gap that only a new log class could expose (F1). The +5b-vs-6-naive precedent collision behind F1 is worth remembering at +freeze time: two cells can each pin a locally-correct reading whose +union is contradictory, and only a cell that sits in the intersection +detects it. diff --git a/formal/reviews/model-spec-round7-overlay.md b/formal/reviews/model-spec-round7-overlay.md new file mode 100644 index 000000000..a725b1a2a --- /dev/null +++ b/formal/reviews/model-spec-round7-overlay.md @@ -0,0 +1,353 @@ +# Round 7 — targeted spot review of the v10 addendum (V-OVERLAY-UNIT) + +Scope: §9 scenario 6 V-OVERLAY-UNIT declaration (pins o-i..o-iv), +cells 6-overlay and 6-overlay-naive (including the "third placement" +dismissal), the §5 overlay-collect-buffer durability row, the 1d +cross-reference, and the §10.5 obligation extensions — per the §11 v10 +change-order entry. Not a full round; v1–v9 material out of scope +except where the addendum destabilizes or newly depends on it. + +Method: mechanical reachability walk of 6-overlay sub-cases (a)–(d) +and 6-overlay-naive's crash window under §3/§4/§5 (prefix rule, +stop/crash checkpoint contents, batch semantics); independent +re-derivation of every P1/P2/P3′ verdict from the §7 fold as written +(round-5 F1 pin applied by hand), including the dismissed third +placement, walked window by window; coherence sweep against the +round-5 V-ATOMIC pins (clause (i)–(iii), F1, F6, N4) and the round-6 +process conventions; shipped-system claims verified against +`docs/verification/sync-replay-6b/plan.md` (B3/B5), +`pkg/sync/source_cache_orchestration.go` (lookup surface 163–215, +`beforeUpserts` 563+, `afterUpserts` publish 718–771), and +`pkg/synccompactor/pebble/overlay.go` (atomic range-del + rows batch +precedent, 353–385). + +Verdict: **REJECT — 3 majors + 2 minors + 2 notes, ALL +fix-without-re-review**; no round 8 warranted. No cell verdict is +overturned under the recoverable readings, but two majors leave a +scripted verdict underivable from the text as written and one +dismisses a placement on a false equivalence. Verified clean (see +list after the findings): the unit-commit fold treatment is genuinely +F1-pin-consistent with no new fold clause; the toggles-off structural +green derives within the scripted family; the naive crash window is +constructible; all shipped-system claims are true in code; the §5 +buffer row is coherent; the 1d cross-reference and §10.5 extensions +are consistent with round-5 F2. + +## Findings + +- **F1 (MAJOR) — pin o-iv is not realizable from the pinned durable + state; 6-overlay sub-case (b) rests on the gap.** + - Claim under attack: "(o-iv) … for a scope with NO marker, resume + restarts the scope's work FROM CONSULT even when a stop-forced + checkpoint restored a mid-chain cursor for it … mid-chain cursors + for unit-mode scopes are restored but IGNORED"; sub-case (b) + scripts exactly this ("stop-checkpoint captures the mid-chain + cursor … resume ignores the cursor (o-iv), re-consults"). + - Evidence: §3 pins that a stack entry holds ONE page token, + advanced in place — "a dispatched-but-unfinished action's stack + entry retains the token of its LAST COMMITTED transition + (mid-chain)" — and the glossary pins `NextPageToken` as in-place + cursor advance. §5 pins "Resume: fresh MSyncAttempt from the MOST + RECENT durable checkpoint, alone." In sub-case (b) the most + recent checkpoint is the stop-forced one whose entry for the + consulting chain holds the mid-overlay cursor; the consult-page + token was destroyed by the in-place advance and exists in no + restored state. After "ignoring" the cursor, the resume has NO + re-entry token: it cannot construct the consult from the + checkpoint alone, and dispatching the mid-chain cursor is the + exact thing o-iv forbids ("cursor continuation without the buffer + is undefined"). A third reading — the worker fails loudly on the + forbidden cursor — produces a P4-shape livelock, turning (b) RED. + Root cause: V-ATOMIC's clause (i) had TWO halves — inline + execution AND "the page's own transition commits only after the + unit". (o-i) generalizes the first half and silently drops the + second; sub-case (b)'s "captures the mid-chain cursor" premise + shows the dropped half was load-bearing. + - Why it matters: the variant's marker-absent resume rule — the + §5 buffer row cites it as the thing buffer loss "forces" — has no + executable semantics, and (b)'s green is the sub-case that makes + the structural claim non-vacuous under graceful stop. This is + not a contradiction-in-principle with the glossary's + stop-resume pin or CO-6b-002 (a declared scenario-local variant + may deviate); it is a joint-unsatisfiability of o-iv with §3's + in-place advance and §5's checkpoint-alone resume. + - Disposition (fix-without-re-review; pick one and pin it): + (1) generalize clause (i) faithfully — transitions of the pages + in a consult verdict's prescribed work commit only at unit + commit, so intermediate overlay cursors never enter live state, + the stop checkpoint captures the chain AT its consult-page + token, o-iv's ignore-rule becomes derivable/vacuous, and + sub-case (b)'s premise text is corrected ("captures the + consult-page cursor", not "the mid-chain cursor"); or + (2) keep per-page transitions and declare that unit-mode stack + entries additionally retain their consult-page token — an + explicit checkpoint-content extension in §5 (and a stated + departure from V-ATOMIC's "token UNCHANGED" pin). Option (1) is + the smaller change and matches V-ATOMIC's discipline. Verdict of + (b) survives either repair. + +- **F2 (MAJOR) — the "third placement" dismissal is unsound: within + the overlay family the reduction to 6-naive's unmarked-debris + class cannot occur, and the placement's real windows are not + covered by any existing cell.** + - Claim under attack: "(The third placement — per-page commits + with marker+publish LAST outside any unit — reduces to 6-naive's + unmarked-debris class and needs no separate cell.)" + - Evidence: 6-naive's class requires a NON-clearing re-verdict + unioning over unmarked debris — its attempt 2 goes FETCH-FRESH, + and "fresh never clears" (1c). In the re-scripted overlay family + the re-consult's failed revalidation yields CHANGED-WITH-DIFF by + premise, whose prescribed work BEGINS with + `eClearScope`+`eCopyScope` (§4; the replayed set is volatile and + lost in the crash, and the family runs `oncePerScope` OFF + besides). Walking the placement's windows: (w1) crash anywhere + before marker+publish → attempt 2 re-consults, the replay page's + clear WIPES the debris, base+overlay rebuild, marker+publish + commit → partition rows(e2)@V2 — no union in any schedule; the + residual is attempt 1's committed copy PLUS attempt 2's committed + copy in one sync — a replacement-count legality question, not a + debris union. (w2) marker-before-publish ordering, crash between + them → marked, entry-less, content-complete scope whose + re-execution is SUPPRESSED by clause (iii) — seals correct + rows(e2) with no entry, and P1-content alarms against the empty + fold (publish was a prescribed round op that never committed) — + a suppression-window shape that is not 6-naive's class either. + Neither window reproduces the union; both are uncovered. + - Why it matters: "needs no separate cell" is a coverage decision + resting on a false equivalence — the flavor of the re-verdict is + exactly what makes the debris classes differ, which is the + addendum's own central insight (stale-AHEAD vs stale-BEHIND). + Worse, (w1) is the FIRST history in the spec whose class depends + on whether "at most one replacement copy per scope per sync" + counts committed copies inside INCOMPLETE rounds: §7's + "replacement-count legality counts COMMITTED copies" was pinned + on cell 4's two-complete-rounds shape, while plan B5 pins the + cross-attempt re-execution copy as legal ("the worst case … + re-runs an idempotent copy"). Under the all-committed-copies + reading (w1) alarms on a converging, B5-legal history; under a + complete-rounds-only reading it is green. No scripted cell + reaches cross-attempt double-copy today, so the pin is genuinely + missing, and out-of-script counterexample logs must fold + identically (round-5 F1's own motivation). + - Disposition (fix-without-re-review): replace the dismissal with + a correct argument or a cheap cell (same premise, shifted op + placement — both windows above are the interesting rows), and + pin the replacement-count rule's treatment of copies in + incomplete rounds. Recommended pin: legality counts committed + copies within COMPLETE rounds, plus the pre-committed- + classification rule that incomplete-round copy debris surfaces + through content divergence (which keeps cell 4 red, keeps + 6-naive red, and keeps the benign at-least-once re-copy green). + +- **F3 (MAJOR) — the P1 fold value for a scope with ZERO complete + rounds is unpinned; two readings exist in the spec's own text and + they diverge on 6-overlay-naive's headline content verdict, while + the cell's attestation claim is underivable under either.** + - Claim under attack: 6-overlay-naive — "the round is INCOMPLETE + … contributes no fold entry; the committed prefix is debris → + P1 content violation at seal (and attestation: entry e2 over an + e1-mosaic partition)"; §10.5 — "6-overlay-naive is content-RED + at seal". + - Evidence: §7 defines the fold "over complete rounds" and never + pins its value when the complete-round set is EMPTY ("current + fold value" is likewise presupposed by the overlay and + copy-skipped clauses, never seeded). 6-overlay-naive is the + first cell whose content verdict depends on the empty case: + every prior red cell had at least one complete round (6-naive + folds fresh(e2); 1b-ii folds rows(e1)). The spec's own 5b text + supplies the competing reading — "invisible to P1 (no legal + round for S — vacuously green)" — under which a scope with no + complete round is simply not checked, and 6-overlay-naive seals + content-GREEN. The intended reading (empty fold = empty + partition; debris diverges) is recoverable from "torn or + INCOMPLETE rounds' debris surfaces as content divergence", but + recoverable-not-pinned with a divergent cell verdict is exactly + the round-5 F1 shape. Separately, the attestation check is + pinned as "the manifest entry's epoch … equals the fold + result's epoch" — an empty fold HAS no epoch, so the comparison + is undefined, not violated; the cell's parenthetical attestation + claim does not follow from the check as written (again a first: + 1b-ii's entry-vs-fold mismatch compared two defined epochs). + - Why it matters: the kill cell of the whole addendum — the one + that answers scenario 6's deferred stale-AHEAD obligation — must + be RED because the property text forces it, not because the + scenario intends it; §10.5's obligation is unverifiable as + written and a checker implementing the vacuous reading passes + the naive variant. + - Disposition (fix-without-re-review), three pins in §7: (a) the + fold's initial value is the EMPTY partition, so a scope with + committed store ops and no complete round diverges by + construction; (b) a published manifest entry for a scope whose + fold result is empty is an ATTESTATION violation (the entry + attests a composition the log does not contain); (c) reword + 5b's "vacuously green" to "green — empty partition equals the + empty fold, and no entry exists to check" so the vacuous reading + loses its textual foothold. Collateral swept: 5b stays green + under (a)+(b) (empty partition, no entry); no other cell has a + non-empty partition or a published entry over an empty fold; + 1d's copy-skipped C publishes over a NON-empty fold + (self-grounding rows(e2)) and keeps its scripted + stale-BEHIND alarm. + +- **F4 (MINOR) — (o-iii) pins the unit's contents unconditionally to + include publish(V_to), but validator-less diff rounds are legal in + the modeled population and the declaration is silent on them.** + - Evidence: §3 MWorker pins "the annotation carries a validator or + not per scenario cell (both shapes are legal per proto)"; plan + B5 pins that a round which never supplies a non-empty validator + gets no entry and the replay remains valid; 1d scripts a + validator-less carrier as a first-class sub-case. V-OVERLAY-UNIT + declares `eOverlayUnit(s)` = {…, publish(V_to)} with V_to "the + verdict's post-diff validator (the new delta token)" — + presupposing the connector supplied one. The round-6 process + lesson ("declared here in full before its cells") makes the + declaration, not the cells, the place where the legal input + space must be total; the v10 §11 entry claims the variant + answers "what the unit publishes for a diff verdict", and the + answer is currently partial. + - Why it matters: an implementer must know whether a + validator-less diff round's unit omits the publish constituent, + synthesizes a validator, or rejects the shape; the three differ + observably (miss next sync vs forged attestation vs loud cold). + - Disposition: one sentence in the declaration — the publish + constituent is present iff the round supplied a non-empty + validator; a publish-less unit commits {clear, copy, overlays, + marker}, leaves no entry (miss next sync, B5-consistent), and + the marker still suppresses re-execution within the sync. No + scripted sub-case changes. + +- **F5 (MINOR) — "B5's early-publish permission is NOT exercised by + the variant" conflates the connector-side permission with the + runtime's frozen publish timing; the deferral is a frozen-contract + deviation on the runtime axis, though verified connector-invisible.** + - Evidence: B5's publish rule is a runtime MANDATE with pinned + timing — "if `SourceCacheReplay.cache_validator` is non-empty, + the manifest entry is published after that page's operations + complete" — and the code publishes per-page in `afterUpserts` + (`source_cache_orchestration.go` 758–771). The "permission" is + the CONNECTOR's option of which page carries the token (1d's + reading: "plan B5 permits the replay page to publish … before + overlay pages land"). Under V-OVERLAY-UNIT the connector still + exercises that option — (o-iii) itself says "the connector still + returns the token on the replay page" — so the permission IS + exercised on the wire; what the variant changes is the runtime's + manifest-write timing, a deviation from B3/B5's frozen per-page + publish that would need a change order if adopted. The + load-bearing half of the claim verifies clean in code: the + consult surface is the PREVIOUS artifact only + (`previousSyncSourceCacheLookup` wraps the previous store's + entry reader, 163–215), so the current sync's manifest is never + connector-readable mid-sync and the deferral is + connector-invisible — "not a wire-contract change" is true. + - Why it matters: the bake-off comparison must not book the + deferral as free; it is a runtime-contract change with a CO + obligation, and "permission not exercised" misattributes whose + behavior changed. Also (o-iii)'s "on the replay page" + over-narrows: B5's other leg (token on a later record/overlay + page) is equally legal and equally buffered into the unit. + - Disposition: reword — the variant defers the runtime's manifest + write into the unit (a B3/B5 timing deviation, change-order + scope if adopted; wire contract untouched, connector-invisible + because the lookup surface is the previous artifact only), and + replace "on the replay page" with "on whichever page carries + it". + +- **F6 (NOTE) — the two-worker marker-race carry-over is the same + hazard CLASS but a materially wider WINDOW; the boundary note + should say so for the deliverable-4 bake-off.** + - V-ATOMIC's N4 window spans one page's handling (marker check → + `eReplayUnit`). V-OVERLAY-UNIT's spans the whole collect phase — + marker check at consult → unit commit after every overlay page + is collected, multiple connector calls and atomic steps. The + class carries over as claimed (two consulting actions both pass + the absent-marker check, two units commit, two committed copies + → P1 legality alarm; unreachable in the scripted + single-consulting-chain family), and one difference from + shipped case 4 is worth recording: because each unit is + internally atomic, the racing schedules' final CONTENT is the + last unit's coherent rows(e_to) — the alarm is legality-only, + never a wipe-mosaic. Stranded-hit inertness carries over + unchanged as claimed (consult-inline + o-iv make a restored hit + inert). Disposition: extend the boundary-note sentence with the + widened-window observation; no cell change. + +- **F7 (NOTE) — 6-overlay-naive's P2 wording misplaces the staleness + counter, and the verification-sync expectations are stated + narrower than what re-derives.** + - "P2 staleness grows without bound on the never-landed rows": + staleness attaches to rows PRESENT in the partition — the growth + is on the stale base(e1) rows whose e1→e2 updates never landed; + the never-landed rows are in no partition. Recomputing P2 in the + verification sync: the per-seal consult clause is GREEN (S is + consulted via V2's validation match, which qualifies under §7's + round-5 pin) — the unbounded growth is the staleness-counter + corollary, case 1's "unbounded branch" vocabulary, and should be + labeled as such. Also true but unclaimed: P1 content stays RED + in the verification sync itself (the replacement fold of the + warm mosaic copy is rows(e2) via truthful V2; the partition is + the mosaic), so an implementer checking only P2 there would + under-report. Disposition: two wording fixes; verdict direction + unchanged. + +## Verified clean (positive results, for the freeze record) + +- Fold treatment of 6-overlay: genuinely consistent with §7 as + written and the round-5 F1 pin — each page's prescribed store ops + commit at unit commit, so round completion IS unit commit; the + round is an overlay round whose own copy committed → + self-grounding, folds rows(e2), copy counts once; no new fold + clause needed. Sub-cases (a), (c), (d) re-derive green exactly as + scripted ((b) pending F1's mechanism pin, after which it + re-derives green too). +- The structural claim is non-vacuous and derivable within the + scripted family with both toggles OFF: the marker-inside-the-unit + is the dedup (at most one unit per scope per sync — a committed + unit implies a marker that suppresses every later execution; an + uncommitted unit implies no copy), and no interleaving partner + exists for `scopeLocks` to matter (single consulting chain, no + carriers by o-i, no record pages). +- 6-overlay-naive's crash window is constructible under §5's prefix + rule (unit', overlay-p1 upsert committed; final upsert dropped; + same-sender FIFO), attempt 2's marker suppression follows clause + (iii) as declared, and the verification sync's warm mosaic replay + is reachable (nothing marks the artifact blocked; V2 revalidates + clean). Stale-AHEAD as the non-self-healing direction re-derives: + V2 attests e2, so no future consult ever re-delivers e1→e2 — the + exact dual of 1d's stale-BEHIND, correctly classified. +- Shipped-system claims: per-page publish at `afterUpserts` when the + page carries a validator (so B5 early publish is real shipped + behavior for validator-bearing replay pages); hit recording at + lookup time via `onHit`; the consult surface is the previous + artifact only. The implementation-shape sentence (WriteBatch / + grouped ingest with range-del + rows in one commit) has an in-repo + precedent (`overlay.go` fold batches combine `DeleteRange` with + row writes in one atomic commit); the model checks contents, not + mechanism, as declared. +- §5 buffer row: coherent — MWorker ownership matches §3 (one worker + runs the entire chain, so the buffer never crosses workers); + volatile-never-checkpointed is consistent with the stop + checkpoint's pinned contents; bound (pages ≤ 2) inside small + scope. +- 1d cross-reference and §10.5: consistent with round-5 F2's + mitigation-dependent demotion; the "same toggles-off configuration + that turns 1d content-red" claim checks out (locks-off 1d is + content-red per round-5 F2; both-off is red a fortiori). +- P3′ claim in 6-overlay: correct — the family's mutation is between + syncs, unit-mode rounds cannot tear, and rows(e2) matches the last + consulted verdict epoch. +- o-iv vs the glossary's stop-resume pin and CO-6b-002: deviation is + declared and legitimate for a scenario-local variant (precedent: + V-ATOMIC's marker suppression, round 5); the defect is F1's + realizability, not contradiction-in-principle. + +## Summary + +| finding | severity | one line | disposition | +|---|---|---|---| +| F1 | MAJOR | o-iv's restart-from-consult has no re-entry token under §3's in-place cursor advance + §5's checkpoint-alone resume; sub-case (b) rests on it | pin transition deferral to unit commit (or explicit token retention); correct (b)'s premise text; fix-without-re-review | +| F2 | MAJOR | third-placement dismissal reduces to 6-naive falsely — the overlay re-verdict CLEARS debris; real windows (cross-attempt double copy, marked-entry-less suppression) are uncovered and expose an unpinned legality-counting case | correct argument or cheap cell; pin replacement counting for incomplete-round copies; fix-without-re-review | +| F3 | MAJOR | empty-fold value unpinned; 5b's "vacuously green" wording supplies a reading that flips 6-overlay-naive content-GREEN; attestation-over-empty-fold undefined | pin empty-fold = empty partition, entry-over-empty-fold = attestation violation, reword 5b; fix-without-re-review | +| F4 | MINOR | unit contents pinned unconditionally with publish(V_to); validator-less diff rounds legal and unhandled | pin publish constituent conditional on a supplied validator; publish-less unit leaves no entry | +| F5 | MINOR | "B5 early-publish permission not exercised" conflates connector permission with the runtime's frozen B3/B5 publish timing (a CO-scope deviation, though verified connector-invisible) | reword; widen "on the replay page" to "whichever page carries it" | +| F6 | NOTE | marker-race carries over in class but with a materially wider window (whole collect phase); racing content is coherent, alarm legality-only | extend the boundary note | +| F7 | NOTE | P2 growth wording misplaces the counter (stale resident base rows, not "never-landed rows"); P2's seal clause is green in the verification sync; P1 also stays red there | wording fixes | diff --git a/formal/walker/CALIBRATION.md b/formal/walker/CALIBRATION.md new file mode 100644 index 000000000..5d91d5956 --- /dev/null +++ b/formal/walker/CALIBRATION.md @@ -0,0 +1,474 @@ +# Walker calibration — run log + +Status: COMPLETE at the v11 freeze + MS-CO-001, extended post-freeze +with the P6-C session-checkpoint-consistency tranche (three cells, +decision 25 — the CO-6b-009 root cause made executable; sweep now 50 +cells). Scenarios 1, 2, 3, 4, +5 (both triggers + crash window + C1 probe), 6 (both flavors + the +round-7 third-placement cell + the MS-CO-001 o-iv mutant), 7, and the +P4 progress cells built and calibrated. Spec baseline: +`formal/MODEL_SPEC.md` v11, FROZEN +(round-7 dispositions + de-scope edits applied; see the §11 v11 +entry), plus change order MS-CO-001 (dispositions for the PARALLEL +round-7 review — `reviews/model-spec-round7-overlay-parallel.md` — +surfaced post-freeze; §3/§4/§5 registration edits, the per-verdict +deferral scoping, and the o-iv-removal kill cell). The v11 monitor +pins (F2 complete-rounds replacement +counting, F3 attestation-over-empty-fold) and the two v11 cells +(6-overlay-last, 3-atomic) are built and verified. FREEZE SWEEP: +all 46 cells, 0 mismatches, every red on its calibrated alarm +(`tools/sweep.sh`, 10k schedules per cell; summary archived at +`traces/freeze-sweep-v11-summary.txt`). The pre-v11 44-cell sweep was +also clean, isolating the P4 merge from the v11 monitor change; the +post-MS-CO-001 47-cell sweep is the current gate. + +Toolchain: P 3.1.0 (`p compile` / `p check -tc -s `). +Counterexample traces are NOT committed (neither the human-readable +schedule nor the machine-replay `trace.json`): archived traces rot +silently as the model evolves, while every red REGENERATES on demand +— re-run the cell's `p check` line and a counterexample lands in +`PCheckerOutput/BugFinding/` at the stated find rate (first find is +seconds-to-minutes on every red below). Only the sweep summaries are +archived under `traces/`. GREEN rows state the explored budget. A +green run means nothing except at the stated budget — the reds are the +calibration currency. + +NOTE on verdict reading: `p check` runs a small portfolio of search +strategies; the aggregate verdict is the "Checker found a bug." line. +A run can print a strategy block reporting 0 bugs AFTER another +strategy found one (observed on tc1c_P2 — red, found by the first +strategy at ~60 schedules, missed by the 100k random pass). + +## Scenario 1 — phantom union (shipped toggles ON in every cell) + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc1a1b_P1 | stop-stranding, carrier publishes, 2 syncs | P1 | RED | RED: `P1-CONTENT` (carrier clear+copy composes with the fresh round; union sealed) | first find; 3000 explored | +| tc1a1b_P3 | same config | P3′ | RED | RED: `P3'-COHERENCE` (1b-i shape: carrier drains after the complete fresh round; content green, epoch incoherent) | first find | +| tc1a1b_P2 | 3 syncs, corollary-run scoping | P2 | RED | RED: `P2-STALENESS` (union replays warm in the verification sync; hops reach 2 — the unbounded branch) | first find | +| tc1bii_P1 | carrier validator-less | P1 | RED | RED: `P1-CONTENT` (the attestation-only 1b-ii edge is also live in this config; the checker surfaces the content shape first) | first find | +| tc1c_P1 | carrier-less hard crash | P1 | RED | RED: `P1-CONTENT` (copy debris survives restart-from-root; fresh round unions over it) | first find | +| tc1c_P2 | crash + verification sync | P2 | RED | RED: `P2-STALENESS` | first find | +| tcGreen_All | no interruption, no mutation, honest replay | P1+P2+P3′ | GREEN | GREEN | 10000 schedules | +| tc1c_P2_honest | crash config, P2 only, 2 syncs | P2 | GREEN | GREEN (the corrupted seal itself is staleness-legal; the alarm belongs to the verification sync) | 3000 schedules | + +## Scenario 2 — session laundering (P6-A; sessions variant A, shipped) + +One sync, root stack [H writer, G reader] (same op, one batch on the +2-cap schedules). H derives-and-writes the session key on EACH of its +two pages; G reads once and emits a row embedding the read value (a +read-miss emits nothing). Both reds are EXPECTED FINDINGS — no fix run +(variant B is the graph addendum's obligation): + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc2stop_P6A | graceful stop, mutate between attempts | P6-A | RED | RED: `P6-A` — H's d1 commits, G embeds d1 and pops; stop strands H mid-chain; H alone re-derives d2 on resume | first find (0.5% of 10k) | +| tc2crash_P6A | hard crash (at-least-once, both re-run) | P6-A | RED | RED: `P6-A` — the G-before-H interleaving re-embeds the durable stale d1 under H's re-derived d2; the complementary H-first schedule is green in the same config | first find (11% of 10k) | +| tc2green_P6A | no interruption, no mutation | P6-A | GREEN | GREEN | 10000 schedules | + +### P6-C — session-checkpoint consistency (CO-6b-009 root cause) + +The constraint P6-A never stated: post-crash session state must equal +the session state at the restored checkpoint, in BOTH directions — +no ZOMBIE (a dead attempt's beyond-checkpoint write observed by the +re-run: the cursor rolled back, the session did not) and no AMNESIA +(a checkpoint-committed value destroyed: its producing work will not +re-run, so deletion is unrecoverable). The axis is `cfg.sessVariant`, +the store's session semantics at the crash boundary: 0 = shipped +(durable at op commit), 1 = the rejected wholesale resume-clear, +2 = checkpoint-consistent sessions (state latched with each +checkpoint, restored at crash — the registered fix). The amnesia +cells run cell 21 (cell 2 with the ROOT ORDER REVERSED so the writer +pops first): under cell 2's LIFO order the reader pops before the +writer, so every checkpoint that still contains the reader predates +the writes and a committed-value-plus-re-run-read history is +structurally unreachable — verified green at 10k before the chassis +was added, which is a reachability fact, not evidence the rejected +fix is sound. + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc2crash_P6C | cell 2, hard crash, sessVariant 0 (shipped) | P6-C | RED | RED: `P6-C-ZOMBIE` — H's un-checkpointed d1 survives the crash; the re-run G reads it before H's re-derivation lands. The SHIPPED defect, now model-caught | first find (3.7% of explored) | +| tc2clear_P6C | cell 21, hard crash, sessVariant 1 (rejected resume-clear) | P6-C | RED | RED: `P6-C-AMNESIA` — H's batch completes, the loop-top checkpoint commits d1, the crash clears the namespace wholesale, G's re-run read misses committed data. The rejected fix, now model-killed | first find (20% of explored) | +| tc2consistent_P6C | cell 21, hard crash, sessVariant 2 (checkpoint-consistent) | P6-C | GREEN | GREEN — rollback to the checkpoint snapshot closes both directions; an un-checkpointed write legally vanishes (the re-run re-derives), a committed value survives | 10000 schedules | + +## Scenario 3 — artifact swap + hit rebind + +Upstream at e2 throughout (preMutate, then never moves); sync 1 seals +A = rows(e2) @ V2; the stop strands the carrier in sync 2 and MEnv +swaps the base to sibling B = rows(e1) @ V1 (equal compat, truthful +validators): + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc3a_P1 | shipped (`hitValidatorBinding` ON) — the residual hole | P1 | RED | RED: `P1-ATTEST-SEAL` (carrier-last shape: rows(B) sealed under entry V_A; the carrier-first/interleaved content shape is also live in the config) — requires the re-consult's lookup-hit V_B to OVERWRITE the hit map before the carrier's LIVE hit read (last-write-wins rebind) | first find (0.34% of 10k — narrow: needs C dispatched after P's re-consult transition) | +| tc3a_P2 | same config | P2 | GREEN | GREEN — attempt 1's validation match qualifies the scope as consulted; copied rows carry hops 1 (corrected expectation; spec v2 wrongly claimed a P2 red) | 10000 schedules | +| tc3b_P1 | pre-CO-6b-004 (`hitValidatorBinding` OFF), 1-page planning (cell 31) | P1 | RED | RED: `P1-ATTEST-SEAL` — no re-consult, hit stays V_A, NO binding check; carrier copies swapped B and publishes V_A | first find (100% of explored) | +| tc3bBindingOn_All | same premise, binding ON — the CO-6b-004 kill | P1+P2+P3′ | GREEN | GREEN — binding gate compares hit V_A to base V_B, fails LOUD-COLD (behavior, not assert); scope seals empty in premise schedules, no wrong data | 10000 schedules | +| tc3atomic_All | v11: same stop+swap premise under V-ATOMIC — the `annotationBinding` de-scope's subsumption witness | P1+P2+P3′ | GREEN | GREEN — no carrier and no annotation exist; either the unit committed (marker in the CURRENT artifact suppresses attempt 2; seal is the unit's coherent contents) or attempt 2 re-consults the actually-current swapped base (V1 fails validation vs e2 → fetch-fresh). The 3A rebind hole is structurally closed: no restored hit authorizes replay | 20000 schedules | + +## Scenario 5 — warm-drift (both produce triggers + the crash window) + +Upstream never moves (drift is config-side). Sync 1 seeds A = rows(e1) +@ V1 with compat record K1 (`baseConfig = 1`); sync 2 is the premise +sync: attempt 1 (warm, K1) consults, records hit {S: V1}, spawns +carrier C (cell-31 planning shape) and the stop strands C. The +scripted drift input (compat recompute / G6 withdrawal) applies to +attempt 2 ONLY in premise histories — see decision 13. Warm install +and both produce-block triggers run at attempt start +(`installProduceState`, MODEL_SPEC 3/4); the blocked flag is volatile +at checkpoint-cadence durability (§5): + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc5a_P1 | cell 51, compat drift K1→K2, `warmGate` OFF — the kill | P1 | RED | RED: `P1-CONFIG` — attempt 2 cold + B4-blocked, but C passes hit (restored) and binding (base unchanged V1) and copies K1-tagged rows into the K2 attempt; sealed rows carry config 1 under seal config 2 | first find (100% of explored) | +| tc5a_Gate_All | cell 51, shipped toggles (`warmGate` ON) | P1+P2+SealExpect | GREEN | GREEN — C fails LOUD-COLD at the warm gate (reason 2), no ops; seal blocked with partition[S] empty | 30000 schedules | +| tc5b_Dropout_All | cell 52, G6 withdrawn in attempt 2, stop script | P1+P2+SealExpect | GREEN | GREEN, and the green IS the required design finding (MODEL_SPEC 9.5b): trigger 2 blocks at install, C's replay-annotated page is SILENTLY IGNORED (B1 — no failure, no announce, no rows), the sync seals green with partition[S] EMPTY and the artifact blocked. P1/P2 are structurally blind (no rows, no round); the scripted `SealExpect` expectation (wantBlocked + wantScopeEmpty) is the dropout's only executable oracle | 30000 schedules | +| tc5b_CrashWindow | cell 52, interrupt 3 (stop attempt 1, crash attempt 2) | SealExpect | RED | RED: `SEAL-EXPECT sealed unblocked` — the crash-window finding: trigger 2's block lives only in attempt 2's volatile flag; the crash lands before any checkpoint carries it; attempt 3 (handling restored, withdrawal is attempt-2-exact) re-detects nothing, runs warm, and seals UNBLOCKED with replayed rows. Schedules where the crash lands after a flag-carrying checkpoint seal blocked and stay green | first find (100% of explored) | +| tc5c_C1Probe | cell 53: ONE action, replay annotation MID-CHAIN (page 0 consults, page 1 replays), plain stop | C1Probe (+P1, P2 clean) | RED | RED: `C1-PROBE` — the CO-6b-002 conformance answer, REACHABLE VIA THE STOP PATH: attempt 21 consults (hit V1 recorded at lookup), the stop strands the action between pages, the checkpoint holds the mid-chain cursor + hit map, and attempt 22's resumed replay page commits its copy with NO fresh consult (hit check passed on the RESTORED map). A finding to confirm against the real implementation via the chaos bridge (deliverable 6), not a model bug — P1/P2 stay green in the same cell (the replayed content is truthful) | first find | + +## Scenario 6 — atomic-unit bake-off + +Fetch-fresh flavor (shipped toggles ON): + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc6naive_P1 | V-NAIVE (marker a separate op after copy), crash script | P1 | RED | RED: `P1-CONTENT` — crash fires at the marker op's queue position; unmarked copy debris; resumed attempt re-consults, revalidation fails, fresh round unions over debris | first find | +| tc6atomic_All | V-ATOMIC (one `eReplayUnit`), same crash script | P1+P2+P3′ | GREEN | GREEN — every crash placement leaves nothing or the complete unit; the marker suppresses re-derivation | 10000 schedules | +| tc6atomicStop_All | V-ATOMIC, stop-stranding script (1a/1b premises) | P1+P2+P3′ | GREEN | GREEN — replay executes inline; the stranded-carrier premise is structurally unreachable | 10000 schedules | + +Changed-with-diff (overlay) flavor, v10 addendum. 6-overlay runs with +`oncePerScope` AND `scopeLocks` OFF (the structural claim); +6-overlay-naive runs shipped toggles — its defect is the unit boundary, +which no toggle repairs: + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc6overlayNaive_P1 | unit misdrawn at the consult boundary ({clear, copy, marker, publish V2} at consult; overlay pages per-page), crash script | P1 | RED | RED: `P1-CONTENT (incomplete-round debris sealed)` — marker suppression seals base(e1)+partial-overlay under entry V2 | first find | +| tc6overlayNaive_P2 | same + verification sync | P2 | RED | RED: `P2-STALENESS` — V2 revalidates clean, the mosaic replays warm; stale-AHEAD is the non-self-healing direction | first find | +| tc6overlayLast_P1 | v11 (round-7 F2): the THIRD placement — no unit; clear+copy per-page at the replay boundary, marker+publish LAST as two trailing ops; crash script | P1 | RED | RED: `P1-CONTENT (incomplete-round debris sealed)` — the w2 window exactly: the trace shows the marker committing and the very next op (publish) dropped by the crash; attempt 2 suppresses on the marker; the scope seals CONTENT-COMPLETE but entry-less, diverging from the EMPTY fold (2.17% of schedules). NO `P1-LEGALITY` appears in any strategy's counterexample — w1's much wider crash window (cross-attempt double copy after the re-verdict's clear wipes the debris) runs green under the complete-rounds counting pin, where the pre-pin monitor would have alarmed on the converging B5-legal history | first find | +| tc6overlayMutO4_P1 | MS-CO-001 (parallel-review F6): the o-iv-REMOVAL mutant — stop script, `o4Mutant` removes the consult reset | P1 | RED | RED: `P1-CONTENT (sealed partition diverges from the round-log fold)` — the resume honors the restored mid-chain cursor with an EMPTY collect buffer, collects only the final overlay page, and commits a unit missing page 1's ops; the self-grounding fold says rows(e2), the partition disagrees (100% of explored). Kills the one load-bearing line the overlay flavor adds beyond V-ATOMIC; the non-mutant sibling stays green in the same config | first find | +| tc6overlay_All | V-OVERLAY-UNIT, crash script | P1+P2+P3′ | GREEN | GREEN | 10000 schedules | +| tc6overlayStop_All | V-OVERLAY-UNIT, stop script (mid-collect aborts; buffer loss; o-iv resume) | P1+P2+P3′ | GREEN | GREEN (re-verified post-MS-CO-001) | 10000 schedules | + +## Scenario 7 — session elision under replay (P6-R; signoff addendum) + +Pure two-sync scripts, no interruption machinery. Kinds W (producer, +scope 0) and R (reader, scope 1) in sequential phases (different ops — +the batch prefix never spans both). W's FRESH enumeration writes K as a +side effect; warm replay is the inline carrier-less path, so ELISION IS +STRUCTURAL. R stamps its fresh rows from its session read (0 = miss); +copied rows carry stamps unchanged. The counterfactual is announced by +MEnv as a computed ghost (= epoch of W's scope this sync). All reds are +deterministic (100% of schedules) — the premises are phase-ordered, not +interleaving-dependent: + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc7a_P6R | write elision: upstream unchanged, R policy always-fresh | P6-R | RED | RED: `P6-R` — W warm, session write elided; R reads MISS, stamps 0; counterfactual v1 | first find | +| tc7a_P1P2 | same config | P1+P2 | GREEN | GREEN — REQUIRED FINDING: the corruption is invisible to content/attestation/staleness checks | 10000 schedules | +| tc7b_P6R | stale-read replay: W's upstream moves between syncs, R warm | P6-R | RED | RED: `P6-R` — R's copied rows carry stamp v1 under counterfactual v2; no elided write anywhere (kills write-only bans) | first find | +| tc7c_All | both-warm control | P1+P2+P3′+P6-A+P6-R | GREEN | GREEN — carried stamps equal the counterfactual; P6-R does not overfit to "replay near sessions" | 10000 schedules | +| tc7aTaintW_P6R | fix run: `sessionTaintWrites` ON | P6-R | GREEN | GREEN — sync N taints W; sync N+1 consults W MISS, re-runs fresh, K present | 10000 schedules | +| tc7bTaintW_P6R | fix run: `sessionTaintWrites` ON, 7b premise | P6-R | RED | RED: `P6-R` — REQUIRED RESIDUAL: R's hazard is a READ; the write-only rule is half a fix | first find | +| tc7aTaintAll_P6R / tc7bTaintAll_P6R | fix run: `sessionTaintAll` ON | P6-R | GREEN | GREEN — replay forfeited exactly where sessions are used (honest price) | 10000 schedules each | + +## Scenario 8 — external principals (P8; the deleteStaleExternalPrincipals contract) + +One sync, one external-phase action (cell 8): page 0 LISTs the +source's current answer and commits the reconciliation op +(`eExtReconReq`); page 1 COPYs the answer's principals (`eExtCopy`). +The ext keyspace is separate from scope partitions (BatonID-annotated +rows beside connector rows). Committed copies are durable across +crashes — the debris premise — and a redispatched external phase +restarts from its root token. MEnv announces a truth ghost +(`eAnnExtTruth`) at sync start and after every between-attempt +mutation; the shrink drops principal 1 (e1 = {0,1} → e2 = {0}). P8 +asserts two clauses: CURRENT — every round's listed answer equals the +source's answer at that moment (a resume must RE-LIST; the +`ResumeUsesCurrentExternalAnswer` chaos pin) — and SEAL — the sealed +ext keyspace equals the last-RUN round's answer exactly (STALE: a dead +attempt's copy survived reconciliation; MISSING: a listed principal +dropped). The seal clause deliberately compares against the last LIST, +not truth-at-seal: a completed-then-crash schedule seals attempt 1's +answer legitimately (sync-scoped freshness). The axes are `extRecon` +(TRUE = the shipped capable-engine path; FALSE = the warn-and-continue +degrade of a non-deleting engine) and `extStaleList` (the recency +mutant: attempts ≥ 2 consume the sync-start answer): + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc8green_P8 | no interruption, no mutation | P8 | GREEN | GREEN — cold baseline | 10000 schedules | +| tc8crash_P8 | hard crash sync 1, shrink between attempts, capable engine | P8 | GREEN | GREEN — every crash placement heals: the resumed attempt re-lists the current answer and reconciliation deletes the dead attempt's stale copies before the fresh writes; completed-then-crash schedules seal attempt 1's answer without re-running the phase (deliberately green — sync-scoped freshness) | 10000 schedules | +| tc8stop_P8 | graceful stop + shrink, capable engine | P8 | GREEN | GREEN — restart-from-root re-lists; no mid-phase cursor can copy a fresh answer over a stale reconciliation | 10000 schedules | +| tc8reconOff_P8 | crash + shrink, `extRecon` OFF (non-deleting engine) | P8 | RED | RED: `P8-EXT-STALE` — the warn-and-continue degrade seals the dead attempt's principal 1 (the SQLite degradation pinned by `SQLiteExternalPrincipalResumeDegradesWithoutFailure`, now model-caught) | first find (20% of explored) | +| tc8staleList_P8 | crash + shrink, `extStaleList` ON (resume consumes the dead attempt's answer) | P8 | RED | RED: `P8-EXT-CURRENT` — the recency mutant the `ResumeUsesCurrentExternalAnswer` chaos pin forbids | first find (100% of explored) | + +## P4 tranche — progress properties (stuck-resume, ladder, leaked lock) + +Scenario-5 chassis (cell 51 premise: stop strands carrier C in sync 2, +compat drifts K1→K2 for the remainder of the sync). Attempt-level loud +failure is ON (`loudColdFailsAttempt`): a warm-gate/binding cold +verdict fails the ATTEMPT (checkpoint forced, `eAnnAttemptFailed`, +resume ladder) instead of completing the chain cold — the deviation +recorded in decision 10 is repaid here. The drift latch makes the +re-failure deterministic: every resume restores the same checkpoint +and meets the same drifted config: + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tcP4stuck_P4 | ladder OFF, 3 attempts | P4Stuck | RED | RED: `P4-STUCK` — attempts 2 and 3 fail at the same scope/cursor/reason from byte-identical restored checkpoint state (CO-6b-004 stuck-resume made executable) | first find | +| tcP4ladder_All | `abandonLadder` ON (k = 2), 2 syncs | P4Live+P1+P2 | GREEN | GREEN — after 2 identical failures the sync is abandoned (sealed=false, resume ladder ends), sync 3 starts COLD from root and seals; the liveness monitor confirms the eventual seal. P4Stuck is deliberately NOT asserted: k = 2 IS the detection event — the ladder's claim is the recovery, not the absence of re-failure | 20000 schedules | +| tcP4leak_P1 | `scopeLocks` ON, warm page fails once, `lockReleaseOnError` OFF | P1 (deadlock) | RED | RED: DEADLOCK — the failed page's retry re-requests the scope lock the dead first try never released; the retry parks forever on `eScopeLockGrant` (CO-6b-007 leaked-lock hang; surfaces as P's deadlock detector, not an assert) | first find | +| tcP4release_All | same premise, `lockReleaseOnError` ON | P1+P2 | GREEN | GREEN — the error path releases before retry; the retry acquires, replays, seals | 20000 schedules | + +## Model decisions of record (change-order candidates for the spec) + +1. **Torn-round exclusion is monitor-side, not config-side.** The spec + (§7 boundary note) argued no §9 config can tear a round because each + config's single stop is consumed by its premise. In the model the + stop's placement is genuinely explored, so torn rounds ARE reachable + (stop mid-fresh-round, resumed in attempt 2). The monitors track + attempt ghosts per round and exclude torn scopes from P1-content and + P3′ rather than trusting configs. Spec §7 should be amended by + change order. +2. **P2 corollary-run scoping** is realized as a config flag + (`verificationOnlyIfInterrupted`): the verification sync runs only in + histories where the scripted interruption landed. Without it, honest + double-replay chains reach hops 2 legally and the ≤1 bound + false-alarms — the flag is the "corollary runs" language of §7 made + operational. +3. **Crash injection is store-armed.** `eCrashArm` lets MStore fire the + crash nondeterministically at any op boundary of the armed gen + (resolution guaranteed at seal). Equivalent to the pinned + queue-position semantics of §5, but every window is explored with + useful probability — pure env-side racing missed the copy→marker + window entirely at 3000 schedules. +4. **Op granularity** per §1: upsert pages are single atomic store ops + ("partitions with atomic page commits"); clear and copy are two + separate atomic steps; V-NAIVE's marker is a third; V-ATOMIC's unit + and V-OVERLAY-UNIT's unit are single ops by design. +5. **Dead-machine parking**: ops from a crashed gen receive `eStoreDead` + and the machines park in terminal states instead of blocking — model + hygiene only (P would otherwise flag the pinned block-forever + semantics as deadlocks). +6. **tc1bii surfaces the content shape first.** The validator-less + config contains both the 1a content schedules and the 1b-ii + attestation schedules; the checker reports the first violation per + run. The attestation edge (`P1-ATTEST-SEAL`) remains an obligation to + surface explicitly — either via a schedule-restricted sub-config or + by inspecting further counterexamples. +7. **`scopeLocks` was inert in scenarios 1/6; load-bearing in 4.** The + case-4 kills (check-then-mark TOCTOU) landed as scripted; the + leaked-lock retry (CO-6b-007 hang) belongs to the P4 tranche. +8. **The hit map is read LIVE, not from the dispatch snapshot.** The + carrier's hit check and binding compare round-trip to the scheduler + at drain time (`eHitReadReq`), matching the shipped one-sync-level- + map, lookup-time-recording, last-write-wins semantics. This is + LOAD-BEARING for 3A: with dispatch-snapshot reads the rebind hole is + structurally unreachable (the carrier can never observe the + re-consult's V_B overwrite) and tc3a_P1 stays green. The replayed + set was already live (lock grant / `eReplayedCheckReq`). +9. **Replacement rounds fold by the base they ACTUALLY copied.** The + P1 fold uses the announce-side `vBase` (the copied base's manifest + entry), not the carrier's believed validator, and a copy-skipped + replacement folds as a NO-OP (round-4 F2). Equal in every scenario- + 1/4/6 cell (belief == base there); the distinction is exactly what + scenario 3 tests — a swapped base folds as its own content and the + belief mismatch surfaces as `P1-ATTEST-SEAL`. +10. **Loud cold is behavior, not an assert.** Binding-gate mismatch + (and, when scenario 5 lands, warm-gate failure) makes the chain + fail cold: no copy, no publish, `eAnnLoudCold` announced. Scenario-3 + schedules reach the gate legitimately in green histories (carrier + drains before the re-consult), so an assert would report fake bugs. + DEVIATION OF RECORD: the real system fails the ATTEMPT (resume + ladder); the model completes the chain cold with no ops. Equivalent + for P1/P2/P3′ (no wrong data either way); the attempt-failure form + becomes load-bearing only in the P4/abandonLadder cells. +11. **P6-A is scoped to this-sync stamps.** Its assert covers rows with + stamp >= 1 AND hops == 0: copied rows carry LAST sync's stamps + (P6-R's domain — cross-sync), and the miss marker 0 is P6-R's 7a + evidence. This realizes the spec's "P6-A is vacuously green on + 7a/7b/7c" without weakening the scenario-2 cells (whose reader + emits hops-0 rows with stamps >= 1, or nothing on a miss). +12. **Produce-side taint is store-recorded, worker-attributed.** The + session ops carry the acting kind's scope and the config's taint + verdict (so MStore stays config-free); taint rotates with the + artifact and a prev-tainted kind's consult MISSES. Checkpoint- + cadence durability of taint marks is not modeled (op-commit) — + accepted for scenario 7 (no interruption in its configs); revisit + if a taint-crash cell is ever scripted. +13. **Scenario-5 drift inputs are premise-scoped.** MEnv applies the + compat recompute / G6 withdrawal to attempt 2 only when the + restored checkpoint holds a stranded (replay-annotated) carrier — + the same spirit as `verificationOnlyIfInterrupted` (decision 2). + Without this, a legal non-premise history (stop lands AFTER C + drains; attempt 1's K1 rows are already sealed-bound) meets the + drifted seal and P1's clause (c) false-alarms on the shipped + design's own mitigated behavior (the artifact seals blocked). The + premise witness (checkpoint introspection) is env-level test + scripting, not modeled machinery. +14. **The seal carries the sealing attempt's blocked flag and compat + config.** `eSealReq`/`eAnnSeal` gained `(blocked, config)`; P1's + clause (c) compares every sealed row's ghost config tag to the seal + config (NOT torn-scope-excluded: config drift is between-attempt by + construction, so a mixed-config scope is exactly the alarm). The + `SealExpect` monitor consumes the scripted `eAnnExpectSeal` + expectation — MODEL_SPEC 9.5b's "scripted seal-state expectation" + made executable. G6 silent-ignore (B1) is a worker-side early + return BEFORE any gate: no ops, no announce, no marks. +15. **Warm install is computed only in the config-modeled cells.** + `installProduceState` (produce read + gates G4/G6/G7 + triggers 1/2 + + compat record write) runs for cells 51/52; every other cell keeps + the calibrated warm=true boot and op stream byte-identical. The + full-sweep regression after the scenario-5 merge confirmed all 35 + prior verdicts unchanged. +16. **Attempt-level loud failure is opt-in per cell.** With + `loudColdFailsAttempt` ON, a cold verdict at the warm/binding gate + sends `eChainFailed`; the scheduler quiesces in-flight workers, + forces a checkpoint, announces the failure (scope, cursor, reason, + restored-state fingerprint), and ends the attempt failed. The + scenario-3/5 gate cells keep the complete-cold-chain form (decision + 10) — their properties are seal-side and both forms are equivalent + there; the P4 cells need the resume ladder itself. +17. **Stuck-detection and the abandon ladder are the same event.** + `P4Stuck` fires on the SECOND identical failure (same restored + checkpoint fingerprint, same failure point); the ladder abandons at + k = 2 — i.e. exactly when detection fires. The ladder cell + therefore asserts recovery (P4Live liveness: abandoned sync's + successor seals) and NOT P4Stuck. `eAttemptEnded` carries `failed` + so MEnv can count identical failures without store introspection. +18. **The leaked-lock hang surfaces as a deadlock, not an assert.** + The failed warm page's retry (same worker, recursion in + `replayPage`) re-requests its scope lock; with `lockReleaseOnError` + OFF the grant never arrives and P's deadlock detector reports the + parked worker — matching CO-6b-007's hang phenomenology (no wrong + data, no progress). +19. **Replacement counting moved to round completion (v11, round-7 + F2 pin).** The P1 monitor counts a scope's committed copies when + their round COMPLETES (same-attempt rounds only), not at copy + commit. Verdict-equal in every pre-v11 cell (cells 4's rounds both + complete, 6-naive's debris copy alarms via content either way); + load-bearing exactly in 6-overlay-last's w1, where the + cross-attempt at-least-once re-copy is B5-legal and must not + alarm. +20. **Attestation over an empty fold is checked at seal (v11, round-7 + F3 pin).** New assert `P1-ATTEST-EMPTY`: a manifest entry for a + non-torn scope with no fold epoch fires outright — covering the + sealed-empty-partition case the content loop never visits. No + pre-v11 cell reaches the shape (copy-skipped publishes always ride + scopes another round grounded); in 6-overlay-naive the content + assert fires first in observed traces, and the direction is red + either way. +21. **o-iv is realized as worker-side cursor reset, equivalent to the + spec's transition deferral (v11 deviation of record).** The spec + pins option (1) of round-7 F1: unit-mode page transitions commit + only at unit commit, so the checkpoint holds the consult token. + The model keeps per-page transitions and instead RESETS a restored + non-zero cursor to the consult page at dispatch — executable here + because model cursors are page indices (the consult re-entry is + always constructible), which is precisely what the real system's + in-place opaque tokens lack (the review's F1 point). Equivalent + for every property: no store op commits before unit commit in + either mechanism, the buffer is volatile in both, and resume + behavior is identical (restart at consult, marker suppression + unchanged). +22. **The third placement commits shipped ops, no new store + machinery.** VAR_OVERLAY_LAST reuses `eClearScope`/`eCopyScope` + (replay boundary), per-page `eUpsertPage`/`eTombstonePage` + (tombstones NOT lastOp), then `eMarkerPut` and `ePublishEntry` + (lastOp) as two trailing queue positions — six crash windows, all + explored by the armed crash. +23. **Two round-7 reviews ran; the model arbitrated their + disagreement (MS-CO-001).** The parallel review + (`reviews/model-spec-round7-overlay-parallel.md`) independently + re-found the empty-fold major and two v11 minors (double-hit + confirmation), judged the third-placement reduction SOUND where + the primary called it false — and the built cell 6-overlay-last + settled it for the primary (the w2 window is red in a non-union + shape; w1 is the legality-counting case the parallel review + itself flagged as a tripwire). Its genuinely new item is the + o-iv-removal kill (decision 24); its registration/wording items + are §3/§4/§5 spec edits with no model impact. +24. **The o-iv mutant is one flag on the realization line.** + `o4Mutant` disables the worker's consult reset (decision 21's + realization of the spec's transition deferral), which is exactly + "resume honors the restored mid-chain cursor". The kill firing at + 100% of explored schedules in the stop config shows the reset is + load-bearing, not vestigial — the strongest possible answer to + "does the model actually depend on o-iv". +25. **Session durability variants are store-side, one field, crash- + boundary-applied (P6-C).** `cfg.sessVariant` rides `eStoreReset` + so MStore stays config-free in spirit (decision 12); variant + semantics apply in `fireCrash` (variant 1 clears `sessionKV`, + variant 2 restores the `sessCkpt` snapshot latched in + `eCheckpointReq`). Applying at the crash commit is equivalent to + acting at resume start: dead-gen ops arriving after the crash are + dropped by the gen gate and can never observe the adjusted map. + The P6-C monitor tracks write provenance from the announce stream + (uncommitted → committed at `eAnnCheckpoint`; uncommitted → + zombie at `eAnnCrash`, unless value-identical to the committed + state, where survival is unobservable; a live rewrite reclaims + the key) and judges reads via the new `eAnnSessionGet` announce. + DISPOSITION LESSON recorded with the cells: scenario 2's original + reds carried the zombie mechanism since calibration but were + filed as a future-runtime obligation; the shipped-code defect + (CO-6b-009) sat unrouted until re-found by hand. Expected-red + findings against SHIPPED semantics must be routed as change + orders on the shipped code, not only as obligations on the + replacement design. +26. **External principals are their own keyspace, phase-shaped, with + an env truth ghost (scenario 8 / P8).** The spec's announce + vocabulary (§7) predates the external phase, so scenario 8 adds + `eAnnExtTruth`/`eAnnExtRound`/`eAnnExtSeal` beside it rather than + inside a scope partition: external rows carry no validator, no + consult, no replay — the only mechanism is LIST (current answer), + RECONCILE (delete what the answer no longer contains), COPY. The + truth ghost is announced by MEnv at sync start and after every + between-attempt mutation, so P8's CURRENT clause always compares a + round's list against the answer live when the attempt listed — + which is what makes the completed-then-crash carry legitimately + green (the seal clause anchors on the last-RUN list, sync-scoped + freshness). The reconciliation op is ONE atomic store pass + (`eExtReconReq`); partial-delete debris reduces to the same + stale-survivor class the crash-between-ops windows already cover, + so no finer granularity is modeled. `extRecon` FALSE is a store + CAPABILITY (the non-deleting engine), not a worker toggle — + the round still announces, because the LIST truly happened; only + reconciliation didn't. + +## Known latent harness race (no bearing on verdicts) + +The env sends `eCrashArm` AFTER `new MSyncAttempt`: a schedule that +starves the env for the entire attempt lets the seal enter the +store's queue ahead of the arm, the at-seal resolution point sees +`armed == false`, and the late arm never resolves — the env +deadlocks on `eCrashAck`. Unreachable in practice under this +project's random-strategy sweeps (needs hundreds of consecutive +starvation steps); found by feedback-PCT on the graph model's G1d +cell, which inherited the same env shape. The graph model fixes it +with a synchronous arm handshake (`eCrashArmed`) before attempt +creation — apply here if this project ever runs priority-based +strategies. Harness-level: no walker verdict depends on schedules +in that regime. + +## Pending + +- Nothing for deliverables 2–3. The 47-cell post-MS-CO-001 sweep ran + clean (0 mismatches, every red on its calibrated alarm; summary + archived at `traces/msco001-sweep-summary.txt`). Deliverable 4's + spec is FROZEN: `formal/GRAPH_MODEL_SPEC.md` v4 after three review + rounds (round 1: REJECT, 11 majors, dispositioned in v2; round 2, + targeted on the adoption repair: core verified sound, REJECT on 6 + seam majors, dispositioned in v3; round 3, targeted on the v3 + repairs: all six round-2 repairs verified sound, REJECT on 2 + fix-without-re-review majors — session-publish body-op pin, + mid-bump fence — dispositioned in v4, no fourth round required — + see the spec's §12 log and `formal/reviews/`). The P project in + `formal/graph/` is BUILT against the frozen v4 spec and its G1 + family is calibrated (10/10 sweep; two calibration-driven change + orders GS-CO-001/GS-CO-002 — see `formal/graph/CALIBRATION.md`). + The walker-side + V-ATOMIC / V-OVERLAY-UNIT pilots (6-atomic, 6-overlay, 3-atomic + re-runs) are its designed hand-off points and their verdicts are + adopted there as settled. diff --git a/formal/walker/PCheckerOutput/sweep/summary.txt b/formal/walker/PCheckerOutput/sweep/summary.txt new file mode 100644 index 000000000..650afb0b2 --- /dev/null +++ b/formal/walker/PCheckerOutput/sweep/summary.txt @@ -0,0 +1,56 @@ +tc1a1b_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1a1b_P2 expected=RED observed=RED ok [P2-STALENESS] +tc1a1b_P3 expected=RED observed=RED ok [P3'-COHERENCE] +tc1bii_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1c_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1c_P1_probe expected=RED observed=RED ok [P1-CONTENT] +tc1c_P2 expected=RED observed=RED ok [P2-STALENESS] +tc1c_P2_honest expected=GREEN observed=GREEN ok +tcGreen_All expected=GREEN observed=GREEN ok +tc2stop_P6A expected=RED observed=RED ok [P6-A,P6A] +tc2crash_P6A expected=RED observed=RED ok [P6-A,P6A] +tc2green_P6A expected=GREEN observed=GREEN ok +tc2crash_P6C expected=RED observed=RED ok [P6-C-ZOMBIE,P6C] +tc2clear_P6C expected=RED observed=RED ok [P6-C-AMNESIA,P6C] +tc2consistent_P6C expected=GREEN observed=GREEN ok +tc3a_P1 expected=RED observed=RED ok [P1-CONTENT] +tc3a_P2 expected=GREEN observed=GREEN ok +tc3b_P1 expected=RED observed=RED ok [P1-ATTEST-SEAL] +tc3bBindingOn_All expected=GREEN observed=GREEN ok +tc3atomic_All expected=GREEN observed=GREEN ok +tc4shipped_All expected=GREEN observed=GREEN ok +tc4atomic_All expected=GREEN observed=GREEN ok +tc4noOnce_P1 expected=RED observed=RED ok [P1-LEGALITY] +tc4noLocks_P1 expected=RED observed=RED ok [P1-LEGALITY] +tc5a_P1 expected=RED observed=RED ok [P1-CONFIG] +tc5a_Gate_All expected=GREEN observed=GREEN ok +tc5b_Dropout_All expected=GREEN observed=GREEN ok +tc5b_CrashWindow expected=RED observed=RED ok [SEAL-EXPECT] +tc5c_C1Probe expected=RED observed=RED ok [C1-PROBE] +tc6naive_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6atomic_All expected=GREEN observed=GREEN ok +tc6atomicStop_All expected=GREEN observed=GREEN ok +tc6overlayNaive_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlayNaive_P2 expected=RED observed=RED ok [P2-STALENESS] +tc6overlayLast_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlayMutO4_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlay_All expected=GREEN observed=GREEN ok +tc6overlayStop_All expected=GREEN observed=GREEN ok +tc7a_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7a_P1P2 expected=GREEN observed=GREEN ok +tc7b_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7c_All expected=GREEN observed=GREEN ok +tc7aTaintW_P6R expected=GREEN observed=GREEN ok +tc7bTaintW_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7aTaintAll_P6R expected=GREEN observed=GREEN ok +tc7bTaintAll_P6R expected=GREEN observed=GREEN ok +tcP4stuck_P4 expected=RED observed=RED ok [P4-STUCK,P4S] +tcP4ladder_All expected=GREEN observed=GREEN ok +tcP4leak_P1 expected=RED observed=RED ok [Deadlock detected,P4L] +tcP4release_All expected=GREEN observed=GREEN ok +tc8green_P8 expected=GREEN observed=GREEN ok +tc8crash_P8 expected=GREEN observed=GREEN ok +tc8stop_P8 expected=GREEN observed=GREEN ok +tc8reconOff_P8 expected=RED observed=RED ok [P8-EXT-STALE] +tc8staleList_P8 expected=RED observed=RED ok [P8-EXT-CURRENT] +SWEEP-DONE cells=55 mismatches=0 diff --git a/formal/walker/PSpec/Monitors.p b/formal/walker/PSpec/Monitors.p new file mode 100644 index 000000000..0f27a0e7d --- /dev/null +++ b/formal/walker/PSpec/Monitors.p @@ -0,0 +1,630 @@ +/* Property monitors (MODEL_SPEC 7). Announce-subscribed; ghost fields + are labels of decisions the model already made (2.4). The fold and + its legality rules implement the round-5 F1 pin: a round completes + at the commit of its last prescribed store op; scheduler transitions + are not fold events; incomplete rounds contribute no fold entry and + their debris surfaces as content divergence. + + Torn rounds (pages committed under more than one attempt) are outside + P1-content's and P3's designed domain (MODEL_SPEC 7 BOUNDARY); the + monitors track attempt ghosts and exclude torn scopes rather than + trusting the configs to never tear — placement of the single stop is + explored, so a torn fresh round is reachable and must not false-alarm. */ + +// Round bookkeeping shared shape: roundId -> info. vBase/hasCopy track +// the replacement copy actually committed (announce-side truth): a +// replacement round folds by the base it COPIED, not by the carrier's +// belief — the distinction scenario 3 (artifact swap) exists to test. +type tRoundInfo = (scope: int, verdict: tVerdict, consultEpoch: int, vBase: int, hasCopy: bool, attempts: map[int, bool], completed: bool); + +spec P1 observes eAnnSyncStart, eAnnClear, eAnnReplay, eAnnUpsert, eAnnTombstones, eAnnPublish, eAnnSeal { + var rounds: map[int, tRoundInfo]; + var foldEpoch: map[int, int]; // scope -> folded content epoch + var copies: map[int, int]; // scope -> committed replacement copies + var tornScopes: map[int, bool]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + rounds = default(map[int, tRoundInfo]); + foldEpoch = default(map[int, int]); + copies = default(map[int, int]); + tornScopes = default(map[int, bool]); + } + on eAnnClear do (p: (syncN: int, scope: int, ghost: tRoundGhost)) { + trackOp(p.scope, p.ghost, false, -1); + } + on eAnnReplay do (p: (syncN: int, scope: int, vBase: int, cBase: int, ghost: tRoundGhost)) { + // Counting/legality moved to round completion (round-7 F2 + // pin): a copy inside a round that never completes is + // pre-committed-classification debris — it surfaces through + // content divergence, never through the count. See trackOp. + trackOp(p.scope, p.ghost, true, p.vBase); + } + on eAnnUpsert do (p: (syncN: int, scope: int, rows: seq[tRow], ghost: tRoundGhost)) { + trackOp(p.scope, p.ghost, false, -1); + } + on eAnnTombstones do (p: (syncN: int, scope: int, removes: seq[int], ghost: tRoundGhost)) { + trackOp(p.scope, p.ghost, false, -1); + } + on eAnnPublish do (p: (syncN: int, scope: int, v: int, ghost: tRoundGhost)) { + // Publish-time check is ATTESTATION ONLY (B5 permits early + // token publish; no content check here). Truthful + // validators are epoch-valued. + assert p.v == p.ghost.consultEpoch, "P1-ATTEST-PUBLISH: published validator epoch differs from the publishing round's verdict epoch"; + trackOp(p.scope, p.ghost, false, -1); + } + on eAnnSeal do (p: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int)) { + var scopes: seq[int]; + var ids: seq[int]; + var i: int; + var j: int; + var s: int; + var have: map[int, int]; + scopes = keys(p.partition); + i = 0; + while (i < sizeof(scopes)) { + s = scopes[i]; + if (!(s in tornScopes)) { + have = contentOf(p.partition, s); + if (s in foldEpoch) { + assert have == rowsAt(foldEpoch[s]), "P1-CONTENT: sealed partition diverges from the round-log fold"; + if (s in p.manifest) { + assert p.manifest[s] == foldEpoch[s], "P1-ATTEST-SEAL: manifest entry epoch differs from the fold epoch"; + } + } else { + // No completed round for this scope: any + // content is incomplete-round debris. + assert sizeof(have) == 0, "P1-CONTENT: incomplete-round debris sealed"; + } + } + // Clause (c) — CONFIG (MODEL_SPEC 7): every sealed + // row's ghost config tag equals the sealing attempt's + // compat config (5a's warmGate kill: K1-tagged rows + // copied into a K2 attempt). Vacuous when configs are + // unmodeled (both sides 0). Torn scopes are NOT + // excluded: config drift is between-attempt by + // construction, so a mixed-config scope is exactly the + // alarm, never a legal smear. + ids = keys(p.partition[s]); + j = 0; + while (j < sizeof(ids)) { + assert p.partition[s][ids[j]].config == p.config, "P1-CONFIG: sealed row's compat config tag differs from the sealing attempt's config"; + j = j + 1; + } + i = i + 1; + } + // Round-7 F3 pin (b): a published manifest entry for a + // scope whose fold result is EMPTY attests a composition + // the round log does not contain — attestation violation + // outright, even when the partition is empty for the scope + // (the sealed-empty case the partition loop never visits). + scopes = keys(p.manifest); + i = 0; + while (i < sizeof(scopes)) { + s = scopes[i]; + if (!(s in tornScopes)) { + assert s in foldEpoch, "P1-ATTEST-EMPTY: manifest entry published over an empty fold"; + } + i = i + 1; + } + } + } + + fun trackOp(scope: int, ghost: tRoundGhost, isCopy: bool, vBase: int) { + var info: tRoundInfo; + if (ghost.roundId in rounds) { + info = rounds[ghost.roundId]; + } else { + info = (scope = scope, verdict = ghost.verdict, consultEpoch = ghost.consultEpoch, vBase = -1, hasCopy = false, attempts = default(map[int, bool]), completed = false); + } + info.attempts[ghost.attempt] = true; + info.consultEpoch = ghost.consultEpoch; + if (isCopy) { + info.hasCopy = true; + info.vBase = vBase; + } + if (ghost.lastOp) { + info.completed = true; + } + rounds[ghost.roundId] = info; + if (sizeof(info.attempts) > 1) { + tornScopes[scope] = true; + } + if (ghost.lastOp && sizeof(info.attempts) == 1) { + // Round completion IS the fold order (completion = commit + // of the last prescribed op; this announce). Fold rule + // (round-5 F1 + round-4 F2): a completed REPLACEMENT round + // folds by the base it ACTUALLY copied (announce-side + // vBase), not the carrier's belief — a swapped base folds + // as its own content, and the mismatch with the published + // entry surfaces as P1-ATTEST-SEAL. A copy-skipped + // replacement (B5-legal duplicate) folds as a NO-OP. Fresh + // and overlay rounds fold their verdict epoch. + // Legality (round-7 F2 pin): replacement counting happens + // HERE — committed copies within COMPLETE rounds only. + // Cross-attempt at-least-once re-copies (the incomplete + // first try) are legal B5 idempotence and stay uncounted. + if (info.hasCopy) { + if (scope in copies) { + copies[scope] = copies[scope] + 1; + } else { + copies[scope] = 1; + } + assert copies[scope] <= 1, "P1-LEGALITY: second complete-round replacement copy for one scope in one sync"; + } + if (ghost.verdict == V_REPLAY) { + if (info.hasCopy) { + foldEpoch[scope] = info.vBase; + } + } else { + foldEpoch[scope] = ghost.consultEpoch; + } + } + } +} + +// Partition scope content as id -> epoch (ghost content tag). +fun contentOf(part: tPartition, scope: int): map[int, int] { + var out: map[int, int]; + var ids: seq[int]; + var i: int; + if (!(scope in part)) { return out; } + ids = keys(part[scope]); + i = 0; + while (i < sizeof(ids)) { + out[ids[i]] = part[scope][ids[i]].epoch; + i = i + 1; + } + return out; +} + +spec P2 observes eAnnScenarioInit, eAnnSyncStart, eAnnConsult, eAnnSeal { + var bound: int; + var consulted: map[int, bool]; + + start state Monitoring { + on eAnnScenarioInit do (p: (maxStaleness: int)) { + bound = p.maxStaleness; + } + on eAnnSyncStart do (p: (syncN: int)) { + consulted = default(map[int, bool]); + } + on eAnnConsult do (p: (syncN: int, scope: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int)) { + // Consulted-against-upstream (MODEL_SPEC 7 pin): validation + // match, fresh fetch, or CHANGED-WITH-DIFF verdict; a lookup + // hit alone does not qualify. + if (p.validated || p.freshFetch || p.diffVerdict) { + consulted[p.scope] = true; + } + } + on eAnnSeal do (p: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int)) { + var scopes: seq[int]; + var ids: seq[int]; + var i: int; + var j: int; + var s: int; + scopes = keys(p.partition); + i = 0; + while (i < sizeof(scopes)) { + s = scopes[i]; + if (sizeof(p.partition[s]) > 0) { + assert s in consulted, "P2-CONSULT: sealed scope not consulted against upstream this sync"; + ids = keys(p.partition[s]); + j = 0; + while (j < sizeof(ids)) { + assert p.partition[s][ids[j]].hops <= bound, "P2-STALENESS: row replay-travel exceeds the scenario bound"; + j = j + 1; + } + } + i = i + 1; + } + } + } +} + +spec P3prime observes eAnnSyncStart, eAnnConsult, eAnnUpsert, eAnnTombstones, eAnnSeal { + var lastEpoch: map[int, int]; // scope -> epoch of last consulted-against-upstream verdict + var attemptsSeen: map[int, map[int, bool]]; // roundId -> attempts (torn tracking) + var tornScopes: map[int, bool]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + lastEpoch = default(map[int, int]); + attemptsSeen = default(map[int, map[int, bool]]); + tornScopes = default(map[int, bool]); + } + on eAnnConsult do (p: (syncN: int, scope: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int)) { + if (p.validated || p.freshFetch || p.diffVerdict) { + lastEpoch[p.scope] = p.epoch; + } + } + on eAnnUpsert do (p: (syncN: int, scope: int, rows: seq[tRow], ghost: tRoundGhost)) { + trackTorn(p.scope, p.ghost); + } + on eAnnTombstones do (p: (syncN: int, scope: int, removes: seq[int], ghost: tRoundGhost)) { + trackTorn(p.scope, p.ghost); + } + on eAnnSeal do (p: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int)) { + var scopes: seq[int]; + var i: int; + var s: int; + scopes = keys(p.partition); + i = 0; + while (i < sizeof(scopes)) { + s = scopes[i]; + // Doubly scoped (MODEL_SPEC 7): configs schedule no + // mid-attempt mutation (env only mutates between + // attempts/syncs), and torn scopes are excluded here. + if (s in lastEpoch && !(s in tornScopes) && sizeof(p.partition[s]) > 0) { + assert contentOf(p.partition, s) == rowsAt(lastEpoch[s]), "P3'-COHERENCE: sealed content epoch differs from last consulted verdict epoch"; + } + i = i + 1; + } + } + } + + fun trackTorn(scope: int, ghost: tRoundGhost) { + var att: map[int, bool]; + if (ghost.roundId in attemptsSeen) { + att = attemptsSeen[ghost.roundId]; + } + att[ghost.attempt] = true; + attemptsSeen[ghost.roundId] = att; + if (sizeof(att) > 1) { + tornScopes[scope] = true; + } + } +} + +// P6-A (MODEL_SPEC 7, case 2): session-embed agreement, WITHIN-SYNC +// form. At seal, every row whose stamp was derived THIS SYNC (hops 0 — +// copied rows carry last sync's stamps and belong to P6-R) and embeds +// a real value (stamp >= 1; the miss marker 0 is P6-R's domain) must +// embed the FINAL session value — comparison is by VALUE, so +// same-value re-derivation is green. Rows with stamp -1 carry no +// session data. The session KV is sync-scoped: tracking resets at +// sync start. P6-A is vacuously green on 7a/7b/7c by this scoping. +spec P6A observes eAnnSyncStart, eAnnSessionSet, eAnnSeal { + var sess: map[int, int]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + sess = default(map[int, int]); + } + on eAnnSessionSet do (p: (syncN: int, key: int, val: int)) { + sess[p.key] = p.val; + } + on eAnnSeal do (p: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int)) { + var scopes: seq[int]; + var ids: seq[int]; + var i: int; + var j: int; + var s: int; + var st: int; + scopes = keys(p.partition); + i = 0; + while (i < sizeof(scopes)) { + s = scopes[i]; + ids = keys(p.partition[s]); + j = 0; + while (j < sizeof(ids)) { + st = p.partition[s][ids[j]].stamp; + if (st >= 1 && p.partition[s][ids[j]].hops == 0) { + assert 0 in sess && sess[0] == st, "P6-A: sealed row embeds a session stamp differing from the final session value"; + } + j = j + 1; + } + i = i + 1; + } + } + } +} + +// P6-C (session-checkpoint consistency; the CO-6b-009 root cause made +// executable). THE CONSTRAINT: observable session state after a crash +// must equal session state at the restored checkpoint — in BOTH +// directions. Direction 1 (ZOMBIE): a value a dead attempt wrote +// AFTER its last checkpoint must not be observable by the re-run — +// the cursor rolled back, the work that produced the value will run +// again, and the re-run window would otherwise consume its own +// future. Direction 2 (AMNESIA): a value observable at the restored +// checkpoint must REMAIN observable — the work that produced it will +// NOT re-run, so deleting it is unrecoverable data loss. Provenance +// is tracked monitor-side from the announce stream: writes are +// uncommitted until an eAnnCheckpoint folds them; a crash turns the +// still-uncommitted residue into zombies (unless value-identical to +// the committed state, where survival is unobservable); a live +// rewrite reclaims the key. Variant 0 (shipped, durable-at-op-commit) +// violates direction 1; the rejected wholesale resume-clear +// (variant 1) violates direction 2; checkpoint-consistent sessions +// (variant 2) satisfy both. +spec P6C observes eAnnSyncStart, eAnnSessionSet, eAnnSessionGet, eAnnCheckpoint, eAnnCrash { + var committed: map[int, int]; // key -> value at the last checkpoint + var uncommitted: map[int, int]; // writes since the last checkpoint + var zombies: map[int, int]; // dead attempts' beyond-checkpoint values + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + committed = default(map[int, int]); + uncommitted = default(map[int, int]); + zombies = default(map[int, int]); + } + on eAnnSessionSet do (p: (syncN: int, key: int, val: int)) { + // A live write takes over the key: whatever is durable now + // is attributable to the current attempt. + uncommitted[p.key] = p.val; + if (p.key in zombies) { zombies -= p.key; } + } + on eAnnCheckpoint do (p: (syncN: int)) { + var ks: seq[int]; + var i: int; + ks = keys(uncommitted); + i = 0; + while (i < sizeof(ks)) { + committed[ks[i]] = uncommitted[ks[i]]; + i = i + 1; + } + uncommitted = default(map[int, int]); + } + on eAnnCrash do (p: (syncN: int)) { + var ks: seq[int]; + var i: int; + var k: int; + ks = keys(uncommitted); + i = 0; + while (i < sizeof(ks)) { + k = ks[i]; + if (!(k in committed && committed[k] == uncommitted[k])) { + zombies[k] = uncommitted[k]; + } + i = i + 1; + } + uncommitted = default(map[int, int]); + } + on eAnnSessionGet do (p: (syncN: int, key: int, found: bool, val: int)) { + if (p.key in zombies) { + assert !(p.found && p.val == zombies[p.key]), "P6-C-ZOMBIE: session read observed a dead attempt's beyond-checkpoint write (the cursor rolled back; the session state did not)"; + } + if (p.key in committed) { + assert p.found, "P6-C-AMNESIA: session read missed a checkpoint-committed value (session data silently deleted; the work that produced it will not re-run)"; + } + } + } +} + +// P8 (external principals, scenario 8 — the deleteStaleExternalPrincipals +// contract made executable). Two clauses. CURRENT: every external +// round's listed answer equals the source's answer at that moment +// (the env truth ghost) — a resumed attempt must RE-LIST, never +// consume a dead attempt's answer (the ResumeUsesCurrentExternalAnswer +// chaos pin). SEAL: the sealed ext keyspace equals the LAST-RUN +// round's listed answer exactly — no dead attempt's copied principal +// survives reconciliation (STALE direction: the non-deleting-engine +// degrade's debris), and nothing listed is dropped (MISSING direction: +// the over-deletion guard). The seal clause compares against the last +// LIST, not the truth at seal time: an attempt that completed the +// phase before a crash seals its own answer legitimately even if the +// source moved afterwards (sync-scoped freshness — the sync is not +// obligated to chase post-completion changes). +spec P8 observes eAnnSyncStart, eAnnExtTruth, eAnnExtRound, eAnnExtSeal { + var truth: map[int, bool]; + var lastLive: map[int, bool]; + var hasRound: bool; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + truth = default(map[int, bool]); + lastLive = default(map[int, bool]); + hasRound = false; + } + on eAnnExtTruth do (p: (syncN: int, ids: seq[int])) { + truth = toSet(p.ids); + } + on eAnnExtRound do (p: (syncN: int, live: seq[int], supported: bool, deleted: seq[int])) { + assert toSet(p.live) == truth, "P8-EXT-CURRENT: external round listed an answer differing from the source's current answer (resume consumed a dead attempt's list)"; + lastLive = toSet(p.live); + hasRound = true; + } + on eAnnExtSeal do (p: (syncN: int, ids: seq[int])) { + var i: int; + var ks: seq[int]; + var sealedSet: map[int, bool]; + if (!hasRound) { return; } + sealedSet = toSet(p.ids); + i = 0; + while (i < sizeof(p.ids)) { + assert p.ids[i] in lastLive, "P8-EXT-STALE: sealed external principal absent from the last-run round's answer (dead attempt's copy survived reconciliation)"; + i = i + 1; + } + ks = keys(lastLive); + i = 0; + while (i < sizeof(ks)) { + assert ks[i] in sealedSet, "P8-EXT-MISSING: external principal listed by the last-run round missing at seal"; + i = i + 1; + } + } + } +} + +fun toSet(ids: seq[int]): map[int, bool] { + var m: map[int, bool]; + var i: int; + i = 0; + while (i < sizeof(ids)) { + m[ids[i]] = true; + i = i + 1; + } + return m; +} + +// P6-R (MODEL_SPEC 7, case 7): replay-session coherence. Per (sync, +// key) the model carries a COUNTERFACTUAL session value — the producer +// policy's phase-final value under an all-fresh execution at this +// sync's epoch (announced by MEnv as a computed ghost). At seal, every +// committed row whose scripted derivation includes a session input +// (stamp >= 0: real values AND the miss marker 0) must match the +// counterfactual. Covers both duals: the fresh reader deriving from a +// read-miss whose producer was elided (7a: counterfactual v1, embedded +// 0) and the replayed row carrying a stamp the producer re-derived +// differently this sync (7b: counterfactual v2, embedded v1 travels +// with the copy). Defined only for configs that mutate upstream +// BETWEEN syncs (single epoch per (sync, scope)). +spec P6R observes eAnnSyncStart, eAnnCounterfactual, eAnnSeal { + var cf: map[int, int]; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + cf = default(map[int, int]); + } + on eAnnCounterfactual do (p: (syncN: int, key: int, val: int)) { + cf[p.key] = p.val; + } + on eAnnSeal do (p: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int)) { + var scopes: seq[int]; + var ids: seq[int]; + var i: int; + var j: int; + var s: int; + var st: int; + scopes = keys(p.partition); + i = 0; + while (i < sizeof(scopes)) { + s = scopes[i]; + ids = keys(p.partition[s]); + j = 0; + while (j < sizeof(ids)) { + st = p.partition[s][ids[j]].stamp; + if (st >= 0 && 0 in cf) { + assert st == cf[0], "P6-R: sealed session-derived row diverges from the all-fresh counterfactual value"; + } + j = j + 1; + } + i = i + 1; + } + } + } +} + +// C1Probe (MODEL_SPEC 9.5 C1, CO-6b-002 conformance question): a +// REACHABILITY probe, not a safety property — its red is the witness +// that a replay copy can commit in an attempt that never freshly +// consulted the scope (the hit check passed on the checkpoint-RESTORED +// hit map after a mid-chain stop-resume). Asserted only in the cell-53 +// probe test; the counterexample trace is the C1 answer ("reachable +// via the stop path"), to be confirmed against the real implementation +// through the chaos bridge (deliverable 6), not treated as a model bug. +spec C1Probe observes eAnnSyncStart, eAnnConsult, eAnnReplay { + var consultedBy: map[int, map[int, bool]]; // scope -> attempt gens + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + consultedBy = default(map[int, map[int, bool]]); + } + on eAnnConsult do (p: (syncN: int, scope: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int)) { + var att: map[int, bool]; + if (p.scope in consultedBy) { att = consultedBy[p.scope]; } + att[p.attempt] = true; + consultedBy[p.scope] = att; + } + on eAnnReplay do (p: (syncN: int, scope: int, vBase: int, cBase: int, ghost: tRoundGhost)) { + assert p.scope in consultedBy && p.ghost.attempt in consultedBy[p.scope], "C1-PROBE: replay copy committed in an attempt with no fresh consult of the scope (restored-hit mid-chain resume) — CO-6b-002 reachable via the stop path"; + } + } +} + +// P4Stuck (MODEL_SPEC 7 P4, safety form): livelock DETECTION checkable +// in bounded runs — two CONSECUTIVE resume attempts that fail from +// identical restored checkpoint state (scheduler-progress fields: +// stack, hits, replayed) with the same verdict (reason) at the same +// step (scope, cursor) constitute the deterministic re-failure finding +// (CO-6b-004's stuck-resume contract). The offending cursor is IN the +// failure checkpoint, so the recurrence is by construction, not luck. +spec P4Stuck observes eAnnSyncStart, eAnnAttemptFailed { + var have: bool; + var lastGen: int; + var lastStack: seq[tAction]; + var lastHits: map[int, int]; + var lastReplayed: map[int, bool]; + var lastScope: int; + var lastReason: int; + var lastCursor: int; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + have = false; + } + on eAnnAttemptFailed do (p: (syncN: int, gen: int, stack: seq[tAction], hits: map[int, int], replayed: map[int, bool], scope: int, reason: int, cursor: int)) { + if (have && p.gen == lastGen + 1) { + assert !(p.stack == lastStack && p.hits == lastHits && p.replayed == lastReplayed && p.scope == lastScope && p.reason == lastReason && p.cursor == lastCursor), "P4-STUCK: consecutive attempts failed from identical restored checkpoint state at the same step (deterministic re-failure, CO-6b-004 stuck-resume)"; + } + have = true; + lastGen = p.gen; + lastStack = p.stack; + lastHits = p.hits; + lastReplayed = p.replayed; + lastScope = p.scope; + lastReason = p.reason; + lastCursor = p.cursor; + } + } +} + +// P4Live (MODEL_SPEC 7 P4, liveness form): hot while a started sync is +// unsealed. An ABANDONED sync (the ladder) stays hot until a LATER +// sync's seal cools it — "after budgets exhaust the chain eventually +// seals" in the bounded scenario shape. Meaningful with abandonLadder +// on; the ladder cell ends cold because the post-abandon sync runs +// cold against the drifted config and seals fresh. +spec P4Live observes eAnnSyncStart, eAnnSeal { + start state Sealed { + on eAnnSyncStart do (p: (syncN: int)) { goto Unsealed; } + ignore eAnnSeal; + } + hot state Unsealed { + on eAnnSeal do (p: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int)) { + goto Sealed; + } + ignore eAnnSyncStart; + } +} + +// SealExpect (MODEL_SPEC 9.5): the scripted seal-state expectation — +// scenario 5's only executable oracle for the produce-blocked marking +// and the 5b silent scope dropout (both invisible to P1/P2: no rows, +// no illegal round). MEnv announces the expectation when the +// stop-stranding premise lands; this sync's seal must satisfy it. +// In the 5b crash cell the wantBlocked check failing IS the +// crash-window finding: the trigger fired volatile in attempt 2 and +// died with it before any checkpoint carried it. +spec SealExpect observes eAnnSyncStart, eAnnExpectSeal, eAnnSeal { + var active: bool; + var expSync: int; + var expScope: int; + var wantBlocked: bool; + var wantScopeEmpty: bool; + + start state Monitoring { + on eAnnSyncStart do (p: (syncN: int)) { + // Expectations are per-sync; a new sync clears any (already + // checked) prior expectation. + if (active && p.syncN != expSync) { active = false; } + } + on eAnnExpectSeal do (p: (syncN: int, scope: int, wantBlocked: bool, wantScopeEmpty: bool)) { + active = true; + expSync = p.syncN; + expScope = p.scope; + wantBlocked = p.wantBlocked; + wantScopeEmpty = p.wantScopeEmpty; + } + on eAnnSeal do (p: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int)) { + if (!active || p.syncN != expSync) { return; } + if (wantBlocked) { + assert p.blocked, "SEAL-EXPECT: artifact sealed unblocked though a produce trigger fired this sync (5b: the crash-window loss)"; + } + if (wantScopeEmpty) { + assert !(expScope in p.partition) || sizeof(p.partition[expScope]) == 0, "SEAL-EXPECT: rows sealed for a scope whose only work was a silently-ignored carrier (5b dropout pin)"; + } + active = false; + } + } +} diff --git a/formal/walker/PSrc/Env.p b/formal/walker/PSrc/Env.p new file mode 100644 index 000000000..edc9d16bc --- /dev/null +++ b/formal/walker/PSrc/Env.p @@ -0,0 +1,347 @@ +/* MEnv: the per-scenario test driver (MODEL_SPEC 3). Owns the sync + chain, attempt lifecycle, interruption scripting (one stop OR one + crash per scenario-1 config), and between-attempt upstream mutation. + + Interruption timing is genuinely explored, not hand-placed: the stop + (or crash) event is sent when the attempt starts and the P scheduler + explores every delivery point in the attempt's lifetime. Schedules + where it lands too late (after seal) are vacuous and legal. + + Crash quiesce (MODEL_SPEC 5): eCrash's queue position at MStore + partitions the dead attempt's ops; dropped ops are never acked, so + dead machines block forever and are abandoned. After eCrashAck no + dead-attempt op can commit (its position was behind the crash). The + sealed-read disambiguates "attempt beat the crash" schedules. */ + +machine MEnv { + var store: machine; + var upstream: machine; + var cfg: tScenarioCfg; + var stopUsed: bool; + var crashUsed: bool; + // Scenario-5 premise flag, re-evaluated per attempt from the + // restored checkpoint: the stop-stranding premise landed iff the + // checkpoint stack holds a replay-annotated carrier. The scripted + // drift inputs (compat recompute, G6 withdrawal) apply only in + // premise histories — non-premise schedules run undrifted and + // green, so exploration never manufactures out-of-premise alarms. + var premise: bool; + // Once compat drift lands it PERSISTS (the recomputed config is + // the new reality): later attempts AND later syncs run K2 — the + // 6c-ladder cell's abandoned-sync successor is cold against the + // K1 base exactly because of this latch. + var drifted: bool; + // Consecutive loud attempt failures this sync (resume-on-failure + // bookkeeping; abandonLadder abandons after k = 2). + var failCount: int; + + start state Run { + entry (c: tScenarioCfg) { + var syncN: int; + var attempt: int; + var gen: int; + var ckpt: tCheckpoint; + var sched: machine; + var syncDone: bool; + var crashedThisAttempt: bool; + var sealedSeen: bool; + var stoppedSeen: bool; + var failedSeen: bool; + var interrupted: bool; + cfg = c; + interrupted = false; + announce eAnnScenarioInit, (maxStaleness = 1,); + store = new MStore(); + upstream = new MUpstream(); + if (cfg.preMutate) { + // Case-3 world: upstream sits at e2 from the start (and + // never moves), so the fabricated sibling artifact B + // (rows at e1) is content-distinct from rows(up). + mutateUpstream(); + } + syncN = 1; + while (syncN <= cfg.nSyncs) { + // P2 corollary-run scoping: the verification sync is + // meaningful only in histories where the scripted + // interruption landed (MODEL_SPEC 7, "corollary runs"). + if (cfg.verificationOnlyIfInterrupted && syncN == cfg.nSyncs && !interrupted) { + break; + } + send store, eStoreReset, (client = this, syncN = syncN, sessVariant = cfg.sessVariant); + receive { case eStoreAck: {} } + announce eAnnSyncStart, (syncN = syncN,); + if (cfg.cell == 7) { + announceCounterfactual(syncN); + } + if (cfg.cell == 8) { + announceExtTruth(syncN); + } + attempt = 1; + syncDone = false; + failCount = 0; + while (!syncDone) { + assert attempt <= 3, "attempt budget exceeded (MODEL_SPEC small scope)"; + gen = syncN * 10 + attempt; + ckpt = attemptCheckpoint(attempt); + premise = hasStrandedCarrier(ckpt); + if (cfg.driftCompat && premise && syncN == cfg.interruptSync && attempt >= 2) { + drifted = true; + } + if ((cfg.cell == 51 || cfg.cell == 52) && syncN == cfg.interruptSync && attempt == 2 && premise) { + announceSealExpectation(syncN); + } + sched = new MSyncAttempt((env = this, store = store, upstream = upstream, gen = gen, syncN = syncN, cfg = cfg, aconfig = attemptConfig(syncN, attempt), g6 = attemptG6(syncN, attempt), ckpt = ckpt)); + crashedThisAttempt = false; + if ((cfg.interrupt == 1 || cfg.interrupt == 3) && syncN == cfg.interruptSync && attempt == 1 && !stopUsed) { + stopUsed = true; + send sched, eStopAttempt; + } + if ((cfg.interrupt == 2 && attempt == 1 || cfg.interrupt == 3 && attempt == 2) && syncN == cfg.interruptSync && !crashUsed) { + crashUsed = true; + crashedThisAttempt = true; + send store, eCrashArm, (client = this, gen = gen); + } + if (crashedThisAttempt) { + receive { case eCrashAck: {} } + send store, eReadSealedReq, (client = this,); + sealedSeen = false; + receive { + case eReadSealedResp: (r: (sealed: bool)) { + sealedSeen = r.sealed; + } + } + if (sealedSeen) { + // The attempt sealed before the crash landed; + // consume its end report and finish the sync. + receive { case eAttemptEnded: (r: (stopped: bool, sealed: bool, failed: bool)) {} } + syncDone = true; + } else { + // Dead attempt (quiesced by ack); apply the + // between-attempt script and resume. + interrupted = true; + betweenAttempts(syncN); + attempt = attempt + 1; + } + } else { + sealedSeen = false; + stoppedSeen = false; + failedSeen = false; + receive { + case eAttemptEnded: (r: (stopped: bool, sealed: bool, failed: bool)) { + sealedSeen = r.sealed; + stoppedSeen = r.stopped; + failedSeen = r.failed; + } + } + if (sealedSeen) { + syncDone = true; + } else { + assert stoppedSeen || failedSeen, "attempt ended neither sealed, stopped, nor failed"; + if (failedSeen) { + // Resume-on-failure (MODEL_SPEC 3): the + // ladder abandons the sync UNSEALED + // after k = 2 identical failures; the + // next sync starts against the last + // sealed artifact (6c ladder). + failCount = failCount + 1; + if (cfg.toggles.abandonLadder && failCount >= 2) { + syncDone = true; + } else { + betweenAttempts(syncN); + attempt = attempt + 1; + } + } else { + interrupted = true; + betweenAttempts(syncN); + attempt = attempt + 1; + } + } + } + } + // Overlay-family premise: one upstream mutation between + // sync 1 and sync 2 (e1 -> e2), none afterwards. + if (cfg.mutateBetweenSyncs && syncN == 1) { + mutateUpstream(); + } + syncN = syncN + 1; + } + goto Finished; + } + } + + state Finished { + ignore eAttemptEnded, eCrashAck; + } + + fun attemptCheckpoint(attempt: int): tCheckpoint { + var root: seq[tAction]; + var ck: tCheckpoint; + var got: bool; + if (attempt == 1) { + return rootCheckpoint(); + } + send store, eReadCheckpointReq, (client = this,); + receive { + case eReadCheckpointResp: (r: (ckpt: tCheckpoint, hasCkpt: bool)) { + ck = r.ckpt; + got = r.hasCkpt; + } + } + if (!got) { + // Crash before any post-Init checkpoint: restart-from-root. + return rootCheckpoint(); + } + return ck; + } + + // Fresh sync root: empty hit map and replayed set (per-sync volatile + // scheduler state). Cell 2 roots TWO same-op actions — H the session + // writer (aid 1) and G the session reader (aid 2) — one batch when + // the nondet cap allows; every other cell roots one planning action. + fun rootCheckpoint(): tCheckpoint { + var root: seq[tAction]; + if (cfg.cell == 2) { + root += (0, (aid = 1, op = OP_PLANNING, scope = 0, cursor = 0, hasAnnotation = false, annotationV = -1, publishes = false)); + root += (1, (aid = 2, op = OP_PLANNING, scope = 0, cursor = 0, hasAnnotation = false, annotationV = -1, publishes = false)); + return (stack = root, hits = default(map[int, int]), replayed = default(map[int, bool]), blocked = false); + } + if (cfg.cell == 21) { + // P6-C chassis: cell 2's actors with the ROOT ORDER + // REVERSED — LIFO pops the writer H first, so a loop-top + // checkpoint can commit H's session write while the reader + // G still has its run ahead of it. That is the amnesia + // premise (checkpoint-committed value + a re-run read), + // structurally unreachable in cell 2 where G pops first. + root += (0, (aid = 2, op = OP_PLANNING, scope = 0, cursor = 0, hasAnnotation = false, annotationV = -1, publishes = false)); + root += (1, (aid = 1, op = OP_PLANNING, scope = 0, cursor = 0, hasAnnotation = false, annotationV = -1, publishes = false)); + return (stack = root, hits = default(map[int, int]), replayed = default(map[int, bool]), blocked = false); + } + if (cfg.cell == 7) { + // Kinds in sequential phases: W (top, popped first) and R + // carry DIFFERENT ops, so the same-op batch prefix never + // spans both — R's phase starts only after W's completes. + root += (0, (aid = 2, op = OP_CARRIER, scope = 1, cursor = 0, hasAnnotation = false, annotationV = -1, publishes = false)); + root += (1, (aid = 1, op = OP_PLANNING, scope = 0, cursor = 0, hasAnnotation = false, annotationV = -1, publishes = false)); + return (stack = root, hits = default(map[int, int]), replayed = default(map[int, bool]), blocked = false); + } + if (cfg.cell == 53) { + // C1-probe root: ONE action carrying the mid-chain replay + // annotation in its token from the start (the policy + // places replay at page 1; the annotation's validator is + // truthful V1). Sync 1 never reaches it (consult misses -> + // fresh chain at cursor 2). + root += (0, (aid = 1, op = OP_PLANNING, scope = 0, cursor = 0, hasAnnotation = true, annotationV = 1, publishes = true)); + return (stack = root, hits = default(map[int, int]), replayed = default(map[int, bool]), blocked = false); + } + root += (0, (aid = 1, op = OP_PLANNING, scope = 0, cursor = 0, hasAnnotation = false, annotationV = -1, publishes = false)); + return (stack = root, hits = default(map[int, int]), replayed = default(map[int, bool]), blocked = false); + } + + // The stop-stranding premise witness: a replay-annotated carrier + // sits in the restored checkpoint stack (spawned by the planning + // consult, undrained when the interruption checkpointed). + fun hasStrandedCarrier(ck: tCheckpoint): bool { + var i: int; + i = 0; + while (i < sizeof(ck.stack)) { + if (ck.stack[i].hasAnnotation) { return true; } + i = i + 1; + } + return false; + } + + // Per-attempt compat config (0 = configs unmodeled). 5a drift + // (trigger 1): attempts >= 2 of the drift sync recompute K2 = + // K1 + 1 — only in premise histories (see the premise var note), + // PERSISTING once landed (the drifted latch). + fun attemptConfig(n: int, attempt: int): int { + if (cfg.baseConfig == 0) { return 0; } + if (drifted) { return cfg.baseConfig + 1; } + return cfg.baseConfig; + } + + // Per-attempt G6 capability bit. 5b withdrawal (trigger 2): attempt + // 2 of the drift sync EXACTLY runs handling-less — attempt 3 (the + // crash cell's resume) has handling back, which is what makes the + // lost block observable rather than re-detected. + fun attemptG6(n: int, attempt: int): bool { + if (cfg.withdrawG6 && premise && n == cfg.interruptSync && attempt == 2) { + return false; + } + return true; + } + + // Scenario-5 seal-state oracle (MODEL_SPEC 9.5b): announced when + // the premise lands, checked by the SealExpect monitor at this + // sync's seal. Both 5a and 5b expect a BLOCKED seal (trigger 1 / + // trigger 2 fired at attempt-2 install); the 5b stop cell also + // pins the silent dropout (partition[S] empty). The 5b crash cell + // wants blocked but may legally seal rows (attempt 3 is warm), and + // its red verdict is the crash-window: a schedule sealing + // UNBLOCKED because the trigger's flag died with attempt 2. + fun announceSealExpectation(n: int) { + announce eAnnExpectSeal, (syncN = n, scope = 0, wantBlocked = true, wantScopeEmpty = cfg.cell == 52 && cfg.interrupt == 1); + } + + // Between-attempt premise script: base swap (case 3), upstream + // mutation (drift premises). Order: swap first — both are env-level + // initial-condition surgery for the NEXT attempt. + fun betweenAttempts(n: int) { + if (cfg.swapBase) { + swapBaseArtifact(); + } + if (cfg.mutateBetweenAttempts) { + mutateUpstream(); + } + // Scenario 8: the truth ghost follows every mutation, so the + // P8 CURRENT clause always compares an attempt's list against + // the answer that was live when the attempt listed. + if (cfg.cell == 8 && cfg.mutateBetweenAttempts) { + announceExtTruth(n); + } + } + + // Case-3 sibling artifact B: truthful rows at e1 under validator 1; + // equal compat record (compat is not modeled as a distinguishing + // axis here — both artifacts are warm-installable); content-distinct + // from rows(up) = rows(e2) because id 1 exists only at e1. + fun swapBaseArtifact() { + var rowsB: seq[tRow]; + rowsB += (0, (id = 0, epoch = 1, hops = 0, config = 0, stamp = -1)); + rowsB += (1, (id = 1, epoch = 1, hops = 0, config = 0, stamp = -1)); + send store, eSwapBase, (client = this, scope = 0, vB = 1, rowsB = rowsB); + receive { case eStoreAck: {} } + } + + fun mutateUpstream() { + send upstream, eMutate, (client = this, scope = 0); + receive { case eMutateAck: {} } + } + + // P6-R counterfactual ghost (MODEL_SPEC 7): W's policy writes + // K = f(epoch of W's scope) as its phase-final value, so the + // all-fresh counterfactual at this sync is exactly that epoch — + // computed by a read, never by a second execution. Sound only + // because case-7 configs mutate upstream BETWEEN syncs (single + // epoch per (sync, scope)). + fun announceCounterfactual(n: int) { + var e: int; + send upstream, eValidateReq, (client = this, scope = 0, v = -1); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { e = r.epoch; } + } + announce eAnnCounterfactual, (syncN = n, key = 0, val = e); + } + + // Scenario-8 truth ghost: the external source's CURRENT answer + // (the truthful epoch table at the current epoch) — computed by a + // read, never by an execution, like the P6-R counterfactual. + fun announceExtTruth(n: int) { + var e: int; + send upstream, eValidateReq, (client = this, scope = 0, v = -1); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { e = r.epoch; } + } + announce eAnnExtTruth, (syncN = n, ids = upstreamRowIds(e)); + } +} diff --git a/formal/walker/PSrc/Events.p b/formal/walker/PSrc/Events.p new file mode 100644 index 000000000..ccca9e354 --- /dev/null +++ b/formal/walker/PSrc/Events.p @@ -0,0 +1,214 @@ +/* Events. Store ops are request/ack: a page's store ops commit (and + announce) before the worker reports its action transition, matching + the shipped synchronous store API (MODEL_SPEC 3: announce on commit; + a page COMMITS when the last of its prescribed store ops commits). + Every attempt-owned request carries gen; the crash protocol drops + ops from dead gens (MODEL_SPEC 5: ops behind eCrash in MStore's + queue are DROPPED — a dropped op is never acked, which also gives + quiesce: dead senders block forever awaiting acks). */ + +// ---- store ops (worker/scheduler -> MStore; eStoreAck on commit) ---- +event eLookupReq: (client: machine, gen: int, scope: int); +event eLookupResp: (hit: bool, v: int); +event eBaseReadReq: (client: machine, gen: int, scope: int); // base-binding check read +event eBaseReadResp: (v: int, present: bool); +event eClearScope: (client: machine, gen: int, scope: int, ghost: tRoundGhost); +event eCopyScope: (client: machine, gen: int, scope: int, ghost: tRoundGhost); +event eUpsertPage: (client: machine, gen: int, scope: int, rows: seq[tRow], ghost: tRoundGhost); +event ePublishEntry: (client: machine, gen: int, scope: int, v: int, ghost: tRoundGhost); +// Scenario-6 marker machinery: the marker is a PER-SCOPE STORE ROW in +// the current artifact — authoritative consult provenance, durable at +// op commit, reset at sync rotation (a new sync always re-consults). +event eMarkerPut: (client: machine, gen: int, scope: int); +event eMarkerReadReq: (client: machine, gen: int, scope: int); +event eMarkerReadResp: (marked: bool); +// V-ATOMIC unit: {clear, copy, marker, publish} committed as ONE atomic +// store op (single queue position — a crash cannot split it). Announces +// its constituent ops so the monitor vocabulary is unchanged; the round +// completes at unit commit (round-5 F1 pin). +event eReplayUnit: (client: machine, gen: int, scope: int, v: int, ghost: tRoundGhost); +// V-OVERLAY-UNIT: {clear, copy(base), overlay upserts/tombstones in +// prescribed page order, marker, publish(V_to)} as ONE atomic store op. +event eOverlayUnit: (client: machine, gen: int, scope: int, v: int, upserts: seq[tRow], removes: seq[int], ghost: tRoundGhost); +// Per-page tombstone commit (shipped path, used by the naive misdraw). +event eTombstonePage: (client: machine, gen: int, scope: int, removes: seq[int], ghost: tRoundGhost); +event eCheckpointReq: (client: machine, gen: int, ckpt: tCheckpoint); +// Seal carries the sealing attempt's produce-blocked flag and compat +// config (blocked last made durable by the forced pre-seal checkpoint; +// the seal is its final resting place on the artifact; config feeds +// P1's clause (c) at seal). +event eSealReq: (client: machine, gen: int, blocked: bool, config: int); +// Case-5 produce state: the artifact's compat record (written by each +// handling attempt at install) and the produce-state read at attempt +// start (install-time gates G4/G7 + block triggers 1/2 read exactly +// this). hasPrev = a previous sealed artifact exists (usable-prev). +event eCompatPut: (client: machine, gen: int, k: int); +event eProduceReadReq: (client: machine, gen: int); +event eProduceReadResp: (prevCompat: int, prevBlocked: bool, curCompat: int, hasCur: bool, hasPrev: bool); +event eStoreAck; +// Response to any op from a dead (crashed) gen: the op was DROPPED, not +// committed. Receivers park in a dead state instead of blocking, so the +// pinned drop semantics don't register as P deadlocks. +event eStoreDead; +// Crash injection (MODEL_SPEC 3 MCrashInjector / 5 crash protocol): +// arming lets MStore fire the crash nondeterministically at any op +// boundary of the armed gen — every queue position is explored with +// per-op granularity. Resolution is guaranteed by the seal op (crash +// fires before or immediately after it), so the env's ack wait always +// terminates. +event eCrashArm: (client: machine, gen: int); +event eCrashAck; +event eStoreReset: (client: machine, syncN: int, sessVariant: int); // begin-of-sync rotation (env, not gen-gated) +event eReadCheckpointReq: (client: machine); +event eReadCheckpointResp: (ckpt: tCheckpoint, hasCkpt: bool); +// Session store (MODEL_SPEC 3/9 cases 2 and 7): sync-scoped KV, durable +// at op commit, survives attempts and crashes within the sync, reset at +// sync rotation. Gen-gated like every attempt-owned op. scope = the +// acting kind's scope (phase attribution for produce-side taint); +// taint = the acting config's toggle verdict for THIS op (computed by +// the worker so the store stays config-free). +event eSessionSet: (client: machine, gen: int, scope: int, key: int, val: int, taint: bool); +event eSessionGetReq: (client: machine, gen: int, scope: int, key: int, taint: bool); +event eSessionGetResp: (found: bool, val: int); +// Case-3 premise: env swaps the previous sealed artifact for a +// fabricated-but-legal sibling B (equal compat record, validator +// vB, content = truthful rows at vB's epoch). Env-level, not gen-gated. +event eSwapBase: (client: machine, scope: int, vB: int, rowsB: seq[tRow]); +// Scenario-8 external-principal ops (MODEL_SPEC abstraction of +// SyncExternalResources). The ext keyspace is separate from scope +// partitions (external principals carry the BatonID annotation and +// live beside connector rows; the model keeps them in their own map). +// eExtReconReq = deleteStaleExternalPrincipals: with supported TRUE +// it deletes every ext row absent from live (the current listed +// answer) as ONE atomic op; with supported FALSE it is the +// warn-and-continue degrade — a no-op that still announces the round +// (the LIST happened; reconciliation did not). +event eExtReconReq: (client: machine, gen: int, live: seq[int], supported: bool); +// eExtCopy = the current answer's principal writes (page-atomic per +// the MODEL_SPEC 1 store abstraction; partial-write debris reduces to +// the same stale-survivor class the crash-between-ops windows cover). +event eExtCopy: (client: machine, gen: int, ids: seq[int]); + +// ---- upstream (synchronous request/response) ---- +event eValidateReq: (client: machine, scope: int, v: int); +event eValidateResp: (ok: bool, epoch: int); +event eFetchReq: (client: machine, scope: int, page: int); +event eFetchResp: (rows: seq[tRow], epoch: int, morePages: bool); +// Overlay diff (changed-with-diff verdict): pages of upserts/removes +// from a base epoch to the current epoch. +event eDiffReq: (client: machine, scope: int, fromEpoch: int, page: int); +event eDiffResp: (upserts: seq[tRow], removes: seq[int], epoch: int, morePages: bool); +event eMutate: (client: machine, scope: int); +event eMutateAck; + +event eReadSealedReq: (client: machine); +event eReadSealedResp: (sealed: bool); + +// ---- scheduler <-> worker ---- +// hits/replayed here are dispatch-time snapshots kept for reference; +// the load-bearing reads are LIVE: the replayed set via lock grant or +// eReplayedCheckReq (case-4 TOCTOU), the hit map via eHitReadReq +// (case-3A rebind). +event eDispatch: (action: tAction, hits: map[int, int], replayed: map[int, bool]); +event eActionTransition: (aid: int, nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int); +event eContinuePage; +event eAbortWorker; +event eWorkerAborted: (aid: int, cursor: int); + +// ---- scope locks + replayed-set access (CO-6b-007 / MODEL_SPEC 4) ---- +// With scopeLocks ON the oncePerScope check-and-mark is lock-mediated: +// the grant carries the replayed status and the release commits the +// mark atomically before the next grant. With locks OFF the worker +// reads the status lock-free and the mark lands later, at the action +// transition — the case-4 check-then-mark TOCTOU window. +event eScopeLockAcquire: (worker: machine, scope: int); +event eScopeLockGrant: (replayed: bool); +event eScopeLockRelease: (scope: int, mark: bool); +event eReplayedCheckReq: (worker: machine, scope: int); +event eReplayedCheckResp: (replayed: bool); +// Live hit-map read (MODEL_SPEC 3: hits live in ONE sync-level map, +// recorded at lookup time, last-write-wins). The carrier's hit check +// and binding compare read this map at DRAIN time — the case-3A +// rebind hole lives in exactly this read-after-overwrite. +event eHitReadReq: (worker: machine, scope: int); +event eHitReadResp: (has: bool, v: int); + +// ---- scheduler self-events (commit/reply/dispatch split so the stop +// can interleave between a transition's state commit and the worker's +// continuation — the stop-stranding premise generator, MODEL_SPEC 9) ---- +event eReplyWorker: (aid: int, worker: machine); +event eDispatchPending; +event eLoopTop; + +// ---- attempt-level loud failure (MODEL_SPEC 4 failure semantics; +// P4 cells only — cfg.loudColdFailsAttempt) ---- +// Worker -> scheduler: a cold verdict failed the chain loudly at the +// offending cursor; the scheduler restores the action at that cursor +// (so the failure recurs deterministically from the checkpoint), +// quiesces, force-checkpoints, and reports the attempt failed. +event eChainFailed: (aid: int, cursor: int, scope: int, reason: int); + +// ---- env control ---- +event eStopAttempt; +event eAttemptEnded: (stopped: bool, sealed: bool, failed: bool); + +// ---- announce vocabulary (MODEL_SPEC 7) ---- +event eAnnScenarioInit: (maxStaleness: int); +event eAnnSyncStart: (syncN: int); +// attempt = the consulting attempt's gen: the C1 probe's oracle +// compares it to the replaying round's attempt ghost (a replay whose +// scope was consulted only in an EARLIER attempt ran on a restored +// hit — the CO-6b-002 conformance question). +event eAnnConsult: (syncN: int, scope: int, hit: bool, v: int, validated: bool, epoch: int, freshFetch: bool, diffVerdict: bool, attempt: int); +// cBase = the copied base content's compat config ghost (first row's +// tag; -1 when the base is empty or configs are unmodeled). P1's +// config clause (c) compares it to the round's attempt config. +event eAnnReplay: (syncN: int, scope: int, vBase: int, cBase: int, ghost: tRoundGhost); +event eAnnClear: (syncN: int, scope: int, ghost: tRoundGhost); +event eAnnUpsert: (syncN: int, scope: int, rows: seq[tRow], ghost: tRoundGhost); +event eAnnTombstones: (syncN: int, scope: int, removes: seq[int], ghost: tRoundGhost); +event eAnnPublish: (syncN: int, scope: int, v: int, ghost: tRoundGhost); +event eAnnCheckpoint: (syncN: int); +event eAnnStop: (syncN: int); +event eAnnCrash: (syncN: int); +// config = the sealing attempt's compat config (0 when unmodeled); +// P1 clause (c) compares every sealed row's ghost tag to it. +event eAnnSeal: (syncN: int, partition: tPartition, manifest: map[int, int], blocked: bool, config: int); +// Scripted seal-state expectation (scenario 5 oracle): announced by +// MEnv when the stop-stranding premise lands; the SealExpect monitor +// checks this sync's seal. wantBlocked: the artifact must seal +// produce-blocked (its violation in the 5b crash cell IS the +// crash-window finding). wantScopeEmpty: partition[scope] must seal +// empty — the 5b silent-dropout pin (the B1-ignored carrier leaves no +// rows and no failure; this scripted expectation is its only +// executable oracle, MODEL_SPEC 9.5b). +event eAnnExpectSeal: (syncN: int, scope: int, wantBlocked: bool, wantScopeEmpty: bool); +// Session announce (P6-A vocabulary): committed session writes and the +// final session KV at seal ride the announce channel like row ops. +event eAnnSessionSet: (syncN: int, key: int, val: int); +event eAnnSessionGet: (syncN: int, key: int, found: bool, val: int); +// P6-R counterfactual ghost (MODEL_SPEC 7): the producer policy's +// phase-final session value under an all-fresh execution at this +// sync's epoch — computable (deterministic policies, sequential +// phases), announced by MEnv at sync start, never executed. +event eAnnCounterfactual: (syncN: int, key: int, val: int); +// Loud-cold: a gate (binding / warm-gate) detected a mismatch and the +// chain failed cold instead of copying — the mitigation's success path. +event eAnnLoudCold: (syncN: int, scope: int, reason: int); // 1=binding, 2=warmGate +// Scenario-8 announce vocabulary (P8). eAnnExtTruth: the env's ghost +// of the external source's CURRENT answer, announced at sync start +// and after every between-attempt mutation — the truth the CURRENT +// clause compares each attempt's list against. eAnnExtRound: the +// store's commit-side record of one external round (the answer the +// attempt listed, whether reconciliation ran, what it deleted). +// eAnnExtSeal: the ext keyspace as sealed, announced with the seal. +event eAnnExtTruth: (syncN: int, ids: seq[int]); +event eAnnExtRound: (syncN: int, live: seq[int], supported: bool, deleted: seq[int]); +event eAnnExtSeal: (syncN: int, ids: seq[int]); +// Attempt-level loud failure record (P4): the RESTORED checkpoint's +// scheduler-progress state (stack/hits/replayed — the ingest-quality +// blocked flag is deliberately excluded: it does not influence the +// verdict) plus the failing step (scope, reason, offending cursor). +// P4Stuck's red = two CONSECUTIVE attempts failing from identical +// restored state at the same step — CO-6b-004's stuck-resume contract. +event eAnnAttemptFailed: (syncN: int, gen: int, stack: seq[tAction], hits: map[int, int], replayed: map[int, bool], scope: int, reason: int, cursor: int); diff --git a/formal/walker/PSrc/Scheduler.p b/formal/walker/PSrc/Scheduler.p new file mode 100644 index 000000000..0961f77c3 --- /dev/null +++ b/formal/walker/PSrc/Scheduler.p @@ -0,0 +1,496 @@ +/* MSyncAttempt: the walker scheduler, one machine per attempt + (MODEL_SPEC 3). LIFO action stack; batch = consecutive same-op + prefix, cap nondet in {1,2}; spawned same-op actions are admitted to + the live batch uncapped. Checkpoints at loop tops (between dispatch + batches) and force-written on graceful stop, capturing live mid-batch + state: mid-chain cursors, admitted-but-undrained spawns, hits + recorded during the aborted batch (GLOSSARY "Checkpoint"). + + The transition-commit / worker-reply / spawn-dispatch split into + separate self-events mirrors the shipped ordering (state commit + precedes queue admission) and is what makes the stop-stranding + premise reachable as a genuine interleaving rather than by + hand-placement (MODEL_SPEC 9, premise generator). */ + +machine MSyncAttempt { + var env: machine; + var store: machine; + var upstream: machine; + var gen: int; + var syncN: int; + var cfg: tScenarioCfg; + var warm: bool; + var aconfig: int; // this attempt's compat config (0 = unmodeled) + var g6: bool; // this attempt's source-cache capability bit + // Produce-blocked flag: ingest-quality state, volatile at + // checkpoint-cadence durability (MODEL_SPEC 5) — restored from the + // checkpoint token, OR'd with this attempt's install triggers, + // durable again only at the next checkpoint and at seal. The 5b + // crash window is a crash landing between the install-time trigger + // and the first checkpoint carrying it. + var blocked: bool; + var stack: seq[tAction]; + var hits: map[int, int]; + var replayed: map[int, bool]; + var workers: seq[machine]; + var busyWith: map[machine, int]; // worker -> aid (absent = free) + var outstanding: map[int, tAction]; // aid -> action at last committed cursor + var owner: map[int, machine]; + var pendingSpawns: seq[tAction]; + var restoreList: seq[tAction]; + var stopping: bool; + var storeDead: bool; // this gen crashed; ops dropped (MODEL_SPEC 5) + var lockHeld: map[int, machine]; // scope -> holding worker + var lockWait: map[int, seq[machine]]; // scope -> waiting workers + // Attempt-level loud failure (P4 cells): the failing step, plus + // the RESTORED checkpoint's progress state for the P4Stuck record. + var failing: bool; + var failScope: int; + var failReason: int; + var failCursor: int; + var restoredStack: seq[tAction]; + var restoredHits: map[int, int]; + var restoredReplayed: map[int, bool]; + + start state Boot { + entry (p: (env: machine, store: machine, upstream: machine, gen: int, syncN: int, cfg: tScenarioCfg, aconfig: int, g6: bool, ckpt: tCheckpoint)) { + env = p.env; store = p.store; upstream = p.upstream; + gen = p.gen; syncN = p.syncN; cfg = p.cfg; + aconfig = p.aconfig; g6 = p.g6; + stack = p.ckpt.stack; + hits = p.ckpt.hits; + replayed = p.ckpt.replayed; + blocked = p.ckpt.blocked; + restoredStack = p.ckpt.stack; + restoredHits = p.ckpt.hits; + restoredReplayed = p.ckpt.replayed; + warm = true; + if (cfg.cell == 51 || cfg.cell == 52) { + installProduceState(); + if (storeDead) { goto DeadState; } + } + workers += (0, new MWorker((scheduler = this, store = store, upstream = upstream, gen = gen, syncN = syncN, cfg = cfg, warm = warm, g6 = g6, aconfig = aconfig))); + workers += (1, new MWorker((scheduler = this, store = store, upstream = upstream, gen = gen, syncN = syncN, cfg = cfg, warm = warm, g6 = g6, aconfig = aconfig))); + goto Running; + } + } + + // Warm install at attempt start (MODEL_SPEC 3, + // installSourceCacheLookup): warm = usable-prev ∧ this attempt's G6 + // bit ∧ G4(prev not replay-blocked) ∧ G7(compat byte-match vs the + // prev artifact's compat record) ∧ no drift this attempt (vs this + // sync's earlier-attempt record). Produce-side block triggers fire + // HERE (install time, MODEL_SPEC 4): trigger 1 = compat recomputed + // differently across attempts of this sync (B4); trigger 2 = this + // attempt runs handling-less (G6 off) over prior-attempt produce + // state. The trigger lands in the VOLATILE blocked flag only. + // A handling attempt then records its own compat config. Scoped to + // the cells that model configs so calibrated op streams elsewhere + // are undisturbed. + fun installProduceState() { + var prevCompat: int; + var prevBlocked: bool; + var curCompat: int; + var hasCur: bool; + var hasPrev: bool; + send store, eProduceReadReq, (client = this, gen = gen); + receive { + case eProduceReadResp: (r: (prevCompat: int, prevBlocked: bool, curCompat: int, hasCur: bool, hasPrev: bool)) { + prevCompat = r.prevCompat; + prevBlocked = r.prevBlocked; + curCompat = r.curCompat; + hasCur = r.hasCur; + hasPrev = r.hasPrev; + } + case eStoreDead: { storeDead = true; } + } + if (storeDead) { return; } + warm = hasPrev && g6 && !prevBlocked && prevCompat == aconfig && (!hasCur || curCompat == aconfig); + if (hasCur && curCompat != aconfig) { blocked = true; } // trigger 1 (B4) + if (!g6 && hasCur) { blocked = true; } // trigger 2 (CO-6b-003) + if (g6) { + send store, eCompatPut, (client = this, gen = gen, k = aconfig); + receive { + case eStoreAck: {} + case eStoreDead: { storeDead = true; } + } + } + } + + state Running { + entry { + loopTop(); + } + + on eLoopTop do { + loopTop(); + } + + on eActionTransition do (p: (aid: int, nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int)) { + var act: tAction; + var w: machine; + // COMMIT the transition into live scheduler state first + // (hit recording pinned at lookup time is carried here; the + // reply to the worker is a separate self-event so a stop can + // land between commit and continuation). + if (p.hasHit) { hits[p.hitScope] = p.hitV; } + if (p.markReplayed) { replayed[p.replayedScope] = true; } + if (p.hasSpawn) { pendingSpawns += (sizeof(pendingSpawns), p.spawn); } + if (p.done) { + w = owner[p.aid]; + outstanding -= p.aid; + owner -= p.aid; + busyWith -= w; + if (p.hasSpawn && !stopping && !failing) { send this, eDispatchPending; } + checkBatchEnd(); + } else { + act = outstanding[p.aid]; + act.cursor = p.nextCursor; + outstanding[p.aid] = act; + send this, eReplyWorker, (aid = p.aid, worker = owner[p.aid]); + if (p.hasSpawn && !stopping && !failing) { send this, eDispatchPending; } + } + } + + on eReplyWorker do (p: (aid: int, worker: machine)) { + if (stopping || failing) { + send p.worker, eAbortWorker; + } else { + send p.worker, eContinuePage; + } + } + + on eDispatchPending do { + dispatchPending(); + } + + on eScopeLockAcquire do (p: (worker: machine, scope: int)) { + var q: seq[machine]; + if (stopping) { + send p.worker, eAbortWorker; + return; + } + if (p.scope in lockHeld) { + if (p.scope in lockWait) { q = lockWait[p.scope]; } + q += (sizeof(q), p.worker); + lockWait[p.scope] = q; + return; + } + lockHeld[p.scope] = p.worker; + send p.worker, eScopeLockGrant, (replayed = p.scope in replayed,); + } + + on eScopeLockRelease do (p: (scope: int, mark: bool)) { + var q: seq[machine]; + var w: machine; + if (p.mark) { replayed[p.scope] = true; } + lockHeld -= p.scope; + if (p.scope in lockWait && sizeof(lockWait[p.scope]) > 0) { + q = lockWait[p.scope]; + w = q[0]; + q -= (0); + lockWait[p.scope] = q; + if (stopping) { + send w, eAbortWorker; + } else { + lockHeld[p.scope] = w; + send w, eScopeLockGrant, (replayed = p.scope in replayed,); + } + } + } + + on eReplayedCheckReq do (p: (worker: machine, scope: int)) { + // Lock-free read (scopeLocks OFF): the mark lands later at + // the transition — the TOCTOU window is real here. + send p.worker, eReplayedCheckResp, (replayed = p.scope in replayed,); + } + + on eHitReadReq do (p: (worker: machine, scope: int)) { + if (stopping) { + send p.worker, eAbortWorker; + return; + } + if (p.scope in hits) { + send p.worker, eHitReadResp, (has = true, v = hits[p.scope]); + } else { + send p.worker, eHitReadResp, (has = false, v = -1); + } + } + + on eStopAttempt do { + var scopes: seq[int]; + var q: seq[machine]; + var i: int; + var j: int; + stopping = true; + announce eAnnStop, (syncN = syncN,); + // Grant-waiters abort at the wait point (their pages restart + // from the current cursor on resume). + scopes = keys(lockWait); + i = 0; + while (i < sizeof(scopes)) { + q = lockWait[scopes[i]]; + j = 0; + while (j < sizeof(q)) { + send q[j], eAbortWorker; + j = j + 1; + } + lockWait -= scopes[i]; + i = i + 1; + } + checkBatchEnd(); + } + + on eWorkerAborted do (p: (aid: int, cursor: int)) { + var act: tAction; + var w: machine; + act = outstanding[p.aid]; + act.cursor = p.cursor; + restoreList += (sizeof(restoreList), act); + w = owner[p.aid]; + outstanding -= p.aid; + owner -= p.aid; + busyWith -= w; + checkBatchEnd(); + } + + on eChainFailed do (p: (aid: int, cursor: int, scope: int, reason: int)) { + // Attempt-level loud failure: the offending action is + // restored AT ITS FAILING CURSOR (so the forced failure + // checkpoint reproduces the premise and the failure recurs + // deterministically on resume — MODEL_SPEC 4). + var act: tAction; + var w: machine; + act = outstanding[p.aid]; + act.cursor = p.cursor; + restoreList += (sizeof(restoreList), act); + w = owner[p.aid]; + outstanding -= p.aid; + owner -= p.aid; + busyWith -= w; + failing = true; + failScope = p.scope; + failReason = p.reason; + failCursor = p.cursor; + checkBatchEnd(); + } + } + + state Done { + ignore eStopAttempt, eActionTransition, eReplyWorker, eDispatchPending, eLoopTop, eWorkerAborted, eScopeLockRelease, eReplayedCheckReq, eChainFailed; + on eScopeLockAcquire do (p: (worker: machine, scope: int)) { + send p.worker, eAbortWorker; + } + on eHitReadReq do (p: (worker: machine, scope: int)) { + send p.worker, eAbortWorker; + } + } + + // Crashed attempt: every op from this gen is dropped. Workers are + // released (aborts) so nothing blocks; the machine parks forever. + // MEnv resumes from the last durable checkpoint independently. + state DeadState { + entry { + var i: int; + i = 0; + while (i < sizeof(workers)) { + send workers[i], eAbortWorker; + i = i + 1; + } + } + on eActionTransition do (p: (aid: int, nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int)) { + if (p.aid in owner) { + send owner[p.aid], eAbortWorker; + } + } + ignore eStopAttempt, eReplyWorker, eDispatchPending, eLoopTop, eWorkerAborted, eScopeLockRelease, eReplayedCheckReq, eChainFailed; + on eScopeLockAcquire do (p: (worker: machine, scope: int)) { + send p.worker, eAbortWorker; + } + on eHitReadReq do (p: (worker: machine, scope: int)) { + send p.worker, eAbortWorker; + } + } + + fun loopTop() { + if (stopping) { + finalizeStopIfQuiesced(); + return; + } + if (failing) { + finalizeFailIfQuiesced(); + return; + } + doCheckpoint(); + if (storeDead) { + goto DeadState; + } + if (sizeof(stack) == 0 && sizeof(outstanding) == 0 && sizeof(pendingSpawns) == 0) { + doSeal(); + return; + } + popBatchAndDispatch(); + } + + fun doCheckpoint() { + var ck: tCheckpoint; + ck = buildCheckpoint(); + send store, eCheckpointReq, (client = this, gen = gen, ckpt = ck); + receive { + case eStoreAck: {} + case eStoreDead: { storeDead = true; } + } + } + + // Checkpoint token contents pinned by MODEL_SPEC 5: action stack + // (with cursors as currently committed, incl. admitted-but-undrained + // spawns and outstanding mid-chain actions), hit map, replayed set. + fun buildCheckpoint(): tCheckpoint { + var st: seq[tAction]; + var i: int; + var aids: seq[int]; + st = stack; + aids = keys(outstanding); + i = 0; + while (i < sizeof(aids)) { + st += (sizeof(st), outstanding[aids[i]]); + i = i + 1; + } + i = 0; + while (i < sizeof(restoreList)) { + st += (sizeof(st), restoreList[i]); + i = i + 1; + } + i = 0; + while (i < sizeof(pendingSpawns)) { + st += (sizeof(st), pendingSpawns[i]); + i = i + 1; + } + return (stack = st, hits = hits, replayed = replayed, blocked = blocked); + } + + fun doSeal() { + send store, eSealReq, (client = this, gen = gen, blocked = blocked, config = aconfig); + receive { + case eStoreAck: {} + case eStoreDead: { storeDead = true; } + } + if (storeDead) { + goto DeadState; + } + send env, eAttemptEnded, (stopped = false, sealed = true, failed = false); + goto Done; + } + + fun popBatchAndDispatch() { + var cap: int; + var batch: seq[tAction]; + var act: tAction; + var op0: tOp; + cap = 1 + choose(2); // nondet in {1, 2} per dispatch + act = stack[sizeof(stack) - 1]; + stack -= (sizeof(stack) - 1); + op0 = act.op; + batch += (sizeof(batch), act); + while (sizeof(stack) > 0 && sizeof(batch) < cap && stack[sizeof(stack) - 1].op == op0) { + act = stack[sizeof(stack) - 1]; + stack -= (sizeof(stack) - 1); + batch += (sizeof(batch), act); + } + while (sizeof(batch) > 0) { + act = batch[0]; + batch -= (0); + dispatchAction(act); + } + } + + fun dispatchAction(act: tAction) { + var w: machine; + var found: bool; + var i: int; + found = false; + i = 0; + while (i < sizeof(workers) && !found) { + if (!(workers[i] in busyWith)) { + w = workers[i]; + found = true; + } + i = i + 1; + } + // At loop tops cap <= worker count; spawns beyond free workers + // wait in pendingSpawns until a worker frees up. + if (!found) { + pendingSpawns += (sizeof(pendingSpawns), act); + return; + } + outstanding[act.aid] = act; + owner[act.aid] = w; + busyWith[w] = act.aid; + send w, eDispatch, (action = act, hits = hits, replayed = replayed); + } + + fun dispatchPending() { + var act: tAction; + if (stopping || failing) { return; } + while (sizeof(pendingSpawns) > 0 && freeWorkerExists()) { + act = pendingSpawns[0]; + pendingSpawns -= (0); + dispatchAction(act); + } + } + + fun freeWorkerExists(): bool { + var i: int; + i = 0; + while (i < sizeof(workers)) { + if (!(workers[i] in busyWith)) { return true; } + i = i + 1; + } + return false; + } + + fun checkBatchEnd() { + if (sizeof(outstanding) > 0) { return; } + if (stopping) { + finalizeStopIfQuiesced(); + return; + } + if (failing) { + finalizeFailIfQuiesced(); + return; + } + if (sizeof(pendingSpawns) > 0) { + dispatchPending(); + return; + } + send this, eLoopTop; + } + + fun finalizeStopIfQuiesced() { + if (sizeof(outstanding) > 0) { return; } + // Force stop-checkpoint of live state: remaining stack, aborted + // actions at their committed cursors, undrained spawns, and the + // hits/replayed recorded during the aborted batch. + doCheckpoint(); + if (storeDead) { + goto DeadState; + } + send env, eAttemptEnded, (stopped = true, sealed = false, failed = false); + goto Done; + } + + // Attempt-level loud failure (P4): quiesce in-flight pages, force + // the failure checkpoint (the offending cursor is IN it — the + // deterministic-recurrence pin), announce the failure record for + // P4Stuck, and report the failed attempt to the env. + fun finalizeFailIfQuiesced() { + if (sizeof(outstanding) > 0) { return; } + doCheckpoint(); + if (storeDead) { + goto DeadState; + } + announce eAnnAttemptFailed, (syncN = syncN, gen = gen, stack = restoredStack, hits = restoredHits, replayed = restoredReplayed, scope = failScope, reason = failReason, cursor = failCursor); + send env, eAttemptEnded, (stopped = false, sealed = false, failed = true); + goto Done; + } +} diff --git a/formal/walker/PSrc/Store.p b/formal/walker/PSrc/Store.p new file mode 100644 index 000000000..0ec894ad3 --- /dev/null +++ b/formal/walker/PSrc/Store.p @@ -0,0 +1,466 @@ +/* MStore: the durable store, one per scenario, holding the artifact + chain (MODEL_SPEC 3). Abstraction per MODEL_SPEC 1: partitions with + atomic page commits and a manifest of scope -> validator entries; + batched clear/copy abstracted to TWO atomic steps (separate ops). + + Crash protocol (MODEL_SPEC 5, pinned): eCrash's position in this + machine's queue partitions the dead attempt's outstanding ops — ops + processed before it committed; ops behind it are dropped when they + arrive (gen check), never processed, never acked. Per-sender FIFO is + P's own delivery guarantee (the WAL property). */ + +machine MStore { + var prevPart: tPartition; // previous artifact (replay source) + var prevMan: map[int, int]; // previous manifest: scope -> validator + var curPart: tPartition; // this sync's artifact + var curMan: map[int, int]; + var ckpt: tCheckpoint; + var hasCkpt: bool; + var deadGens: map[int, bool]; + var syncN: int; + var sealed: bool; + var armed: bool; + var armedGen: int; + var armedClient: machine; + var curMarkers: map[int, bool]; // scenario-6 markers, per current sync + // Session store (cases 2, 7): sync-scoped KV, durable at op commit. + // Survives attempts and crashes within the sync (committed writes + // are durable; the crash protocol only drops UNPROCESSED ops); + // reset at sync rotation like the checkpoint token. + var sessionKV: map[int, int]; + // Session durability variant (P6-C, cfg.sessVariant): sessCkpt is + // the session state latched with the last committed checkpoint — + // consumed only by variant 2 (checkpoint-consistent rollback). + var sessVariant: int; + var sessCkpt: map[int, int]; + // Produce-side session taint (case-7 fix runs): kinds (scopes here) + // marked non-replayable in the artifact being produced. Rotates + // with the artifact; the NEXT sync's consult on a prev-tainted + // kind returns MISS (degradation, not a loud verdict). + var curTaint: map[int, bool]; + var prevTaint: map[int, bool]; + // Case-5 produce state: compat records (per artifact; -1 = none) + // and the sealed artifact's produce-blocked flag. + var curCompat: int; + var prevCompat: int; + var sealedBlocked: bool; + var prevBlocked: bool; + // Scenario-8 external-principal keyspace (BatonID-annotated rows, + // separate from scope partitions). Durable at op commit like every + // row write: a dead attempt's committed copies SURVIVE the crash — + // which is exactly why eExtReconReq exists. + var extRows: map[int, bool]; + + start state Serving { + on eStoreReset do (p: (client: machine, syncN: int, sessVariant: int)) { + // Begin-of-sync rotation: the sealed artifact becomes the + // replay source; the new artifact starts empty; the + // checkpoint token belongs to a sync and does not survive it. + if (sealed) { + prevPart = curPart; + prevMan = curMan; + prevTaint = curTaint; + prevCompat = curCompat; + prevBlocked = sealedBlocked; + } + curPart = default(tPartition); + curMan = default(map[int, int]); + curMarkers = default(map[int, bool]); + curTaint = default(map[int, bool]); + curCompat = -1; + sealedBlocked = false; + sessionKV = default(map[int, int]); + sessVariant = p.sessVariant; + sessCkpt = default(map[int, int]); + extRows = default(map[int, bool]); + hasCkpt = false; + ckpt = default(tCheckpoint); + sealed = false; + syncN = p.syncN; + send p.client, eStoreAck; + } + + on eSessionSet do (p: (client: machine, gen: int, scope: int, key: int, val: int, taint: bool)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + sessionKV[p.key] = p.val; + if (p.taint) { curTaint[p.scope] = true; } + announce eAnnSessionSet, (syncN = syncN, key = p.key, val = p.val); + send p.client, eStoreAck; + } + + on eSessionGetReq do (p: (client: machine, gen: int, scope: int, key: int, taint: bool)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + if (p.taint) { curTaint[p.scope] = true; } + if (p.key in sessionKV) { + announce eAnnSessionGet, (syncN = syncN, key = p.key, found = true, val = sessionKV[p.key]); + send p.client, eSessionGetResp, (found = true, val = sessionKV[p.key]); + } else { + announce eAnnSessionGet, (syncN = syncN, key = p.key, found = false, val = 0); + send p.client, eSessionGetResp, (found = false, val = 0); + } + } + + on eExtReconReq do (p: (client: machine, gen: int, live: seq[int], supported: bool)) { + var ids: seq[int]; + var liveSet: map[int, bool]; + var deleted: seq[int]; + var i: int; + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + i = 0; + while (i < sizeof(p.live)) { + liveSet[p.live[i]] = true; + i = i + 1; + } + if (p.supported) { + // The capable path: delete every ext row the current + // answer no longer contains (one atomic pass — + // deleteStaleExternalPrincipals runs before the + // current answer's writes). + ids = keys(extRows); + i = 0; + while (i < sizeof(ids)) { + if (!(ids[i] in liveSet)) { + deleted += (sizeof(deleted), ids[i]); + extRows -= ids[i]; + } + i = i + 1; + } + } + // supported FALSE: warn-and-continue — the round still + // announces (the list happened), nothing is deleted. + announce eAnnExtRound, (syncN = syncN, live = p.live, supported = p.supported, deleted = deleted); + send p.client, eStoreAck; + } + + on eExtCopy do (p: (client: machine, gen: int, ids: seq[int])) { + var i: int; + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + i = 0; + while (i < sizeof(p.ids)) { + extRows[p.ids[i]] = true; + i = i + 1; + } + send p.client, eStoreAck; + } + + on eCompatPut do (p: (client: machine, gen: int, k: int)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + curCompat = p.k; + send p.client, eStoreAck; + } + + on eProduceReadReq do (p: (client: machine, gen: int)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + send p.client, eProduceReadResp, (prevCompat = prevCompat, prevBlocked = prevBlocked, curCompat = curCompat, hasCur = curCompat > 0, hasPrev = sizeof(prevMan) > 0); + } + + on eSwapBase do (p: (client: machine, scope: int, vB: int, rowsB: seq[tRow])) { + // Case-3 premise: replace the previous sealed artifact for + // this scope with sibling B. Env-level initial-condition + // surgery (B is a legal artifact from another history), not + // an attempt op — no gen gate, no crash point. + var i: int; + var m: map[int, tRow]; + i = 0; + while (i < sizeof(p.rowsB)) { + m[p.rowsB[i].id] = p.rowsB[i]; + i = i + 1; + } + prevPart[p.scope] = m; + prevMan[p.scope] = p.vB; + send p.client, eStoreAck; + } + + on eLookupReq do (p: (client: machine, gen: int, scope: int)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + // A kind tainted in the previous artifact's produce state + // consults MISS (case-7 fix runs): replay is forfeited. + if (p.scope in prevMan && !(p.scope in prevTaint)) { + send p.client, eLookupResp, (hit = true, v = prevMan[p.scope]); + } else { + send p.client, eLookupResp, (hit = false, v = -1); + } + } + + on eBaseReadReq do (p: (client: machine, gen: int, scope: int)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + if (p.scope in prevMan) { + send p.client, eBaseReadResp, (v = prevMan[p.scope], present = true); + } else { + send p.client, eBaseReadResp, (v = -1, present = false); + } + } + + on eClearScope do (p: (client: machine, gen: int, scope: int, ghost: tRoundGhost)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + curPart[p.scope] = default(map[int, tRow]); + announce eAnnClear, (syncN = syncN, scope = p.scope, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eCopyScope do (p: (client: machine, gen: int, scope: int, ghost: tRoundGhost)) { + var ids: seq[int]; + var i: int; + var r: tRow; + var dst: map[int, tRow]; + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + if (p.scope in curPart) { dst = curPart[p.scope]; } + if (p.scope in prevPart) { + ids = keys(prevPart[p.scope]); + i = 0; + while (i < sizeof(ids)) { + r = prevPart[p.scope][ids[i]]; + // P2 ghost: replay travel increments the hop counter. + r.hops = r.hops + 1; + dst[r.id] = r; + i = i + 1; + } + } + curPart[p.scope] = dst; + announce eAnnReplay, (syncN = syncN, scope = p.scope, vBase = prevManValue(prevMan, p.scope), cBase = baseConfigOf(prevPart, p.scope), ghost = p.ghost); + send p.client, eStoreAck; + } + + on eUpsertPage do (p: (client: machine, gen: int, scope: int, rows: seq[tRow], ghost: tRoundGhost)) { + var i: int; + var dst: map[int, tRow]; + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + if (p.scope in curPart) { dst = curPart[p.scope]; } + i = 0; + while (i < sizeof(p.rows)) { + dst[p.rows[i].id] = p.rows[i]; + i = i + 1; + } + curPart[p.scope] = dst; + announce eAnnUpsert, (syncN = syncN, scope = p.scope, rows = p.rows, ghost = p.ghost); + send p.client, eStoreAck; + } + + on ePublishEntry do (p: (client: machine, gen: int, scope: int, v: int, ghost: tRoundGhost)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + curMan[p.scope] = p.v; + announce eAnnPublish, (syncN = syncN, scope = p.scope, v = p.v, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eMarkerPut do (p: (client: machine, gen: int, scope: int)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + curMarkers[p.scope] = true; + send p.client, eStoreAck; + } + + on eMarkerReadReq do (p: (client: machine, gen: int, scope: int)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + send p.client, eMarkerReadResp, (marked = p.scope in curMarkers,); + } + + on eReplayUnit do (p: (client: machine, gen: int, scope: int, v: int, ghost: tRoundGhost)) { + var ids: seq[int]; + var i: int; + var r: tRow; + var dst: map[int, tRow]; + var g: tRoundGhost; + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + // One atomic commit: clear, copy, marker, publish. The + // constituent announces fire together at commit; the last + // (publish) carries lastOp — round completion IS unit commit. + curPart[p.scope] = default(map[int, tRow]); + g = p.ghost; + g.lastOp = false; + announce eAnnClear, (syncN = syncN, scope = p.scope, ghost = g); + dst = curPart[p.scope]; + if (p.scope in prevPart) { + ids = keys(prevPart[p.scope]); + i = 0; + while (i < sizeof(ids)) { + r = prevPart[p.scope][ids[i]]; + r.hops = r.hops + 1; + dst[r.id] = r; + i = i + 1; + } + } + curPart[p.scope] = dst; + announce eAnnReplay, (syncN = syncN, scope = p.scope, vBase = prevManValue(prevMan, p.scope), cBase = baseConfigOf(prevPart, p.scope), ghost = g); + curMarkers[p.scope] = true; + curMan[p.scope] = p.v; + announce eAnnPublish, (syncN = syncN, scope = p.scope, v = p.v, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eTombstonePage do (p: (client: machine, gen: int, scope: int, removes: seq[int], ghost: tRoundGhost)) { + var i: int; + var dst: map[int, tRow]; + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + if (p.scope in curPart) { dst = curPart[p.scope]; } + i = 0; + while (i < sizeof(p.removes)) { + if (p.removes[i] in dst) { dst -= p.removes[i]; } + i = i + 1; + } + curPart[p.scope] = dst; + announce eAnnTombstones, (syncN = syncN, scope = p.scope, removes = p.removes, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eOverlayUnit do (p: (client: machine, gen: int, scope: int, v: int, upserts: seq[tRow], removes: seq[int], ghost: tRoundGhost)) { + var ids: seq[int]; + var i: int; + var r: tRow; + var dst: map[int, tRow]; + var g: tRoundGhost; + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + // ONE atomic commit: clear, copy(base), overlay upserts and + // tombstones in prescribed page order, marker, publish(V_to). + // Constituent announces fire together; publish carries + // lastOp — round completion IS unit commit, and the round + // folds as the self-grounding overlay (own copy committed). + g = p.ghost; + g.lastOp = false; + curPart[p.scope] = default(map[int, tRow]); + announce eAnnClear, (syncN = syncN, scope = p.scope, ghost = g); + dst = curPart[p.scope]; + if (p.scope in prevPart) { + ids = keys(prevPart[p.scope]); + i = 0; + while (i < sizeof(ids)) { + r = prevPart[p.scope][ids[i]]; + r.hops = r.hops + 1; + dst[r.id] = r; + i = i + 1; + } + } + i = 0; + while (i < sizeof(p.upserts)) { + dst[p.upserts[i].id] = p.upserts[i]; + i = i + 1; + } + announce eAnnReplay, (syncN = syncN, scope = p.scope, vBase = prevManValue(prevMan, p.scope), cBase = baseConfigOf(prevPart, p.scope), ghost = g); + announce eAnnUpsert, (syncN = syncN, scope = p.scope, rows = p.upserts, ghost = g); + i = 0; + while (i < sizeof(p.removes)) { + if (p.removes[i] in dst) { dst -= p.removes[i]; } + i = i + 1; + } + announce eAnnTombstones, (syncN = syncN, scope = p.scope, removes = p.removes, ghost = g); + curPart[p.scope] = dst; + curMarkers[p.scope] = true; + curMan[p.scope] = p.v; + announce eAnnPublish, (syncN = syncN, scope = p.scope, v = p.v, ghost = p.ghost); + send p.client, eStoreAck; + } + + on eCheckpointReq do (p: (client: machine, gen: int, ckpt: tCheckpoint)) { + maybeCrash(); + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + ckpt = p.ckpt; + hasCkpt = true; + // Checkpoint-consistent sessions (variant 2): the session + // overlay flushes atomically with the checkpoint token. + if (sessVariant == 2) { sessCkpt = sessionKV; } + announce eAnnCheckpoint, (syncN = syncN,); + send p.client, eStoreAck; + } + + on eSealReq do (p: (client: machine, gen: int, blocked: bool, config: int)) { + // Guaranteed resolution point for an armed crash: it fires + // either just before the seal (dropping it) or right after. + if (armed && armedGen == p.gen) { + if (choose(2) == 0) { + fireCrash(); + } else { + sealed = true; + sealedBlocked = p.blocked; + announce eAnnExtSeal, (syncN = syncN, ids = keys(extRows)); + announce eAnnSeal, (syncN = syncN, partition = curPart, manifest = curMan, blocked = p.blocked, config = p.config); + send p.client, eStoreAck; + fireCrash(); + return; + } + } + if (p.gen in deadGens) { send p.client, eStoreDead; return; } + sealed = true; + sealedBlocked = p.blocked; + announce eAnnExtSeal, (syncN = syncN, ids = keys(extRows)); + announce eAnnSeal, (syncN = syncN, partition = curPart, manifest = curMan, blocked = p.blocked, config = p.config); + send p.client, eStoreAck; + } + + on eReadCheckpointReq do (p: (client: machine)) { + send p.client, eReadCheckpointResp, (ckpt = ckpt, hasCkpt = hasCkpt); + } + + on eReadSealedReq do (p: (client: machine)) { + send p.client, eReadSealedResp, (sealed = sealed,); + } + + on eCrashArm do (p: (client: machine, gen: int)) { + armed = true; + armedGen = p.gen; + armedClient = p.client; + } + } + + fun maybeCrash() { + if (armed && choose(2) == 0) { + fireCrash(); + } + } + + fun fireCrash() { + deadGens[armedGen] = true; + armed = false; + // Session state at the crash boundary (P6-C). Variant 0 + // (shipped) keeps sessionKV untouched: writes beyond the last + // checkpoint survive the cursor rollback (the zombie + // direction). Variant 1 models the rejected wholesale + // resume-clear: checkpoint-committed data is destroyed too + // (the amnesia direction). Variant 2 rolls sessions back to + // the state latched with the last checkpoint — both + // directions closed. Equivalent to acting at resume start: + // dead-gen ops arriving after the crash are dropped by the + // gen gate and can never observe the adjusted map. + if (sessVariant == 1) { + sessionKV = default(map[int, int]); + } + if (sessVariant == 2) { + sessionKV = sessCkpt; + } + announce eAnnCrash, (syncN = syncN,); + send armedClient, eCrashAck; + } +} + +fun prevManValue(m: map[int, int], scope: int): int { + if (scope in m) { return m[scope]; } + return -1; +} + +// Config ghost of the copied base content: rows in a scope share one +// attempt config, so the first row's tag stands for the base. -1 when +// the base is empty or configs are unmodeled (all rows tag 0 -> the +// caller treats 0 as unmodeled too). +fun baseConfigOf(part: tPartition, scope: int): int { + var ids: seq[int]; + if (scope in part) { + ids = keys(part[scope]); + if (sizeof(ids) > 0) { return part[scope][ids[0]].config; } + } + return -1; +} diff --git a/formal/walker/PSrc/Types.p b/formal/walker/PSrc/Types.p new file mode 100644 index 000000000..b0deed688 --- /dev/null +++ b/formal/walker/PSrc/Types.p @@ -0,0 +1,218 @@ +/* Types for the walker + source-cache replay calibration model. + Source of truth: formal/MODEL_SPEC.md (v10). Identifiers follow + formal/GLOSSARY.md. Small scope: 1-2 scopes, epochs 1..3, row ids + 0..1, <=3 syncs, <=3 attempts/sync, 2 workers, <=2 pages/round. */ + +// A stored row. epoch is the ghost content tag (truthful upstream), +// hops is the P2 replay-travel counter (0 = fresh this sync), +// config is the P1 config ghost, stamp the session ghost (-1 none, 0 miss). +type tRow = (id: int, epoch: int, hops: int, config: int, stamp: int); + +// scope -> row id -> row +type tPartition = map[int, map[int, tRow]]; + +// Mitigation toggles (MODEL_SPEC 6). OFF removes a check, never adds. +// The sessionTaint pair is produce-side (scenario 7 fix runs): session +// traffic during a replay-capable kind's phase marks that kind +// non-replayable in the artifact being produced; the NEXT sync's +// consult on a tainted kind misses (degradation, not a loud verdict). +type tToggles = ( + warmGate: bool, + hitValidatorBinding: bool, + scopeLocks: bool, + oncePerScope: bool, + annotationBinding: bool, // de-scoped from build; kept for spec parity + abandonLadder: bool, + sessionTaintWrites: bool, + sessionTaintAll: bool +); + +// Verdict classes (P1 ghost "verdict class"; GLOSSARY "verdict"). +enum tVerdict { V_REPLAY, V_FRESH, V_OVERLAY } + +// Action ops. PLANNING consults and may spawn; CARRIER carries a replay +// annotation; FRESH_PAGES is the continuation of a fetch-fresh chain. +// One op per kind (round-6 F1 pin: kind = (op, scope)). +enum tOp { OP_PLANNING, OP_CARRIER } + +// An action on the scheduler stack. cursor is the page index the chain +// resumes from (0 = root token; restart-from-root restores 0 unless a +// stop-forced checkpoint captured a mid-chain cursor). +type tAction = ( + aid: int, // action id, unique per sync + op: tOp, + scope: int, + cursor: int, + hasAnnotation: bool, // carrier: replay annotation present in token + annotationV: int, // the annotation's validator (epoch-valued) + publishes: bool // carrier publishes its validator (1b-i vs 1b-ii) +); + +// Checkpoint token (MODEL_SPEC 5): action stack (with cursors as +// captured), hit map, replayed set, and the ingest-quality fragment +// the build models: the produce-blocked flag (checkpoint-cadence +// durability — the scenario-5b crash-window finding lives in exactly +// this field). compositionEnum remains de-scoped (v11). +type tCheckpoint = ( + stack: seq[tAction], + hits: map[int, int], // scope -> hit validator + replayed: map[int, bool], // replayed set (map as set) + blocked: bool // produce-blocked reason flag +); + +// Design variant (MODEL_SPEC 9 scenario 6). Not a mitigation toggle: +// it alters commit structure. 0 = shipped; 1 = V-NAIVE (marker as a +// separate op after eCopyScope, outside any unit); 2 = V-ATOMIC +// (eReplayUnit: clear+copy+marker+publish as ONE atomic store op; +// replay executes inline on the consulting page — no carrier spawns; +// the marker check precedes the consult and suppresses re-consult and +// re-derivation for marked scopes — clause (iii) applies to both). +// v10 addendum: VAR_OVERLAY_UNIT = V-OVERLAY-UNIT (unit boundary at the +// consult VERDICT: base copy + all overlay pages + marker + publish in +// ONE atomic op; per-page ops buffered volatile; publish deferred into +// the unit; marker-absent resume restarts from consult, mid-chain +// cursors ignored — pin o-iv). VAR_OVERLAY_NAIVE = the misdraw: the +// unit {clear, copy, marker, publish(V_to)} commits at the CONSULT +// boundary; overlay pages then commit per-page (6-overlay-naive kill). +// VAR_OVERLAY_LAST = the third placement (round-7 F2): NO unit at all — +// clear+copy commit per-page at the replay boundary, overlay pages +// per-page via the shipped path, then marker and publish(V_to) trail +// LAST as two separate ops (6-overlay-last: w2 marker-committed/ +// publish-lost suppression is the P1 witness; w1's cross-attempt +// re-copy exercises the complete-rounds replacement-counting pin). +enum tVariant { VAR_SHIPPED, VAR_NAIVE, VAR_ATOMIC, VAR_OVERLAY_NAIVE, VAR_OVERLAY_UNIT, VAR_OVERLAY_LAST } + +// Scenario configuration, built per test cell in PTst. Constructed via +// defaultCfg() + field overrides (P named tuples are order-sensitive). +type tScenarioCfg = ( + scenario: int, + variant: tVariant, + // Premise SHAPE of the planning chain / root stack: + // 1 = 2-page planning, spawn at page 1, re-consult at page 2 (1a/1b, 3A) + // 2 = session laundering: root stack [H writer, G reader] (case 2) + // 3 = 1-page planning, consult+replay inline (1c, 6-family) + // 4 = 2-page planning spawning dual carriers (case 4) + // 7 = sessions x replay: kinds W (scope 0, producer) then R + // (scope 1, reader) in sequential phases (case 7) + // 31 = 1-page planning, consult+spawn then done (3B) + // 51 = 5a shape: cell-31 planning + warm/produce machinery, + // compat drift between attempts (trigger 1) + // 52 = 5b shape: cell-31 planning + warm/produce machinery, + // G6 capability withdrawal in attempt 2 (trigger 2) + // 53 = C1 probe: one action, replay annotation MID-CHAIN (page 0 + // consults, page 1 replays); stop between the pages resumes + // the replay on the restored hit map without a fresh consult + cell: int, + // Interruption script: 0 = none, 1 = graceful stop, 2 = hard + // crash; 3 = stop in attempt 1 THEN hard crash in attempt 2 (the + // 5b crash-window premise). Fired in sync interruptSync only. + interrupt: int, + interruptSync: int, + toggles: tToggles, + carrierPublishes: bool, // 1b-i vs 1b-ii sub-cells + nSyncs: int, // total syncs incl. verification + mutateBetweenAttempts: bool, + mutateBetweenSyncs: bool, + preMutate: bool, // advance upstream to e2 before sync 1 (case 3) + swapBase: bool, // between-attempt base swap to artifact B (case 3) + // Case-7a reader policy: R's connector fetches fresh regardless of + // a valid hit (verdicts are connector choice; replay is opt-in). + readerAlwaysFresh: bool, + // Case-5 warm/produce axes. baseConfig: the compat config K of + // attempt 1 (0 = configs unmodeled in this cell). driftCompat: + // attempts >= 2 compute K2 != K1 (trigger 1 / B4). withdrawG6: + // attempt 2 runs without source-cache handling (trigger 2). + baseConfig: int, + driftCompat: bool, + withdrawG6: bool, + // P2 corollary-run scoping (MODEL_SPEC 7: "corollary runs assert + // staleness <= 1"): the verification sync runs only in histories + // where the scripted interruption actually landed; otherwise the + // honest double-replay chain reaches hops 2 legally and the <=1 + // bound is outside its run class. + verificationOnlyIfInterrupted: bool, + // P4 tranche axes (MODEL_SPEC 4 failure semantics / 7 P4): + // loudColdFailsAttempt = a cold verdict fails the ATTEMPT loudly + // (resume-on-failure; the offending cursor is checkpointed and the + // failure recurs deterministically). Default false = the chain-cold + // simplification of decision 10, load-bearing only in P4 cells. + loudColdFailsAttempt: bool, + // warmPageFails = inject ONE destination-write failure on the + // replay page after the scope lock is acquired (CO-6b-007 premise); + // the worker retries in-attempt, re-entering the page sequence. + warmPageFails: bool, + // lockReleaseOnError = the release-on-error edge (shipped). The + // mutation check REMOVES it: the in-attempt retry then deadlocks + // on its own leaked lock — the CO-6b-007 hang. + lockReleaseOnError: bool, + // o4Mutant = the o-iv-REMOVAL mutant (MS-CO-001 / parallel-review + // F6): a V-OVERLAY-UNIT resume HONORS a restored mid-chain cursor + // instead of restarting at the consult — the retry collects only + // the final page into an empty buffer and commits a unit missing + // the first page's overlay ops (content-RED in sub-case (b)). + o4Mutant: bool, + // Session durability variant at the crash boundary (P6-C, the + // CO-6b-009 root cause): 0 = shipped (durable at op commit — + // beyond-checkpoint writes survive the cursor rollback); + // 1 = the rejected wholesale resume-clear (checkpoint-committed + // data destroyed); 2 = checkpoint-consistent sessions (session + // state latched with each checkpoint, restored at crash). + sessVariant: int, + // Scenario-8 axes (external principals; cell 8). extRecon models + // the storage engine's delete capability: TRUE = the shipped + // capable path (deleteStaleExternalPrincipals reconciles a dead + // attempt's copied principals before the current answer is + // written); FALSE = the warn-and-continue degrade (non-deleting + // engine) — stale principals survive to seal. extStaleList is the + // resume-recency mutant: attempts >= 2 list the SYNC-START answer + // instead of the current one (the behavior the + // ResumeUsesCurrentExternalAnswer chaos pin forbids). + extRecon: bool, + extStaleList: bool +); + +// Base config: shipped design, no interruption, no mutation, 2 syncs. +fun defaultCfg(): tScenarioCfg { + return ( + scenario = 0, + variant = VAR_SHIPPED, + cell = 1, + interrupt = 0, + interruptSync = 2, + toggles = (warmGate = true, hitValidatorBinding = true, scopeLocks = true, oncePerScope = true, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = false), + carrierPublishes = true, + nSyncs = 2, + mutateBetweenAttempts = false, + mutateBetweenSyncs = false, + preMutate = false, + swapBase = false, + readerAlwaysFresh = false, + baseConfig = 0, + driftCompat = false, + withdrawG6 = false, + verificationOnlyIfInterrupted = false, + loudColdFailsAttempt = false, + warmPageFails = false, + lockReleaseOnError = true, + o4Mutant = false, + sessVariant = 0, + extRecon = true, + extStaleList = false + ); +} + +// Consult outcome handed from store+upstream to the worker. +type tConsult = (hit: bool, v: int, validated: bool); + +// Round ghost label carried on store ops for the P1 fold: +// (verdict class, consult epoch, attempt config) + round identity and +// a lastOp marker (round completion = commit of last prescribed op, +// round-5 F1 pin). +type tRoundGhost = ( + roundId: int, + verdict: tVerdict, + consultEpoch: int, + config: int, + lastOp: bool, + attempt: int // gen; a round whose pages commit under >1 attempt is TORN +); diff --git a/formal/walker/PSrc/Upstream.p b/formal/walker/PSrc/Upstream.p new file mode 100644 index 000000000..790430e6e --- /dev/null +++ b/formal/walker/PSrc/Upstream.p @@ -0,0 +1,91 @@ +/* MUpstream: the external system of record (MODEL_SPEC 3). + Truthful: a validator (epoch-valued) validates iff it equals the + current epoch. Row table: epoch 1 has rows {0,1}; epoch >= 2 has {0} + (row 1 deleted upstream at the e1->e2 mutation), so unions and + resurrections are content-visible with 2 row ids (MODEL_SPEC 8). */ + +// Row ids present at an epoch. Shared by MUpstream (fetch) and the +// monitors (the rows(s,e) fold table) so the oracle and the system +// draw from one table. +fun upstreamRowIds(epoch: int): seq[int] { + var ids: seq[int]; + ids += (0, 0); + if (epoch <= 1) { + ids += (1, 1); + } + return ids; +} + +// rows(s, e) as id -> content-epoch map (monitor-side fold table). +fun rowsAt(epoch: int): map[int, int] { + var ids: seq[int]; + var m: map[int, int]; + var i: int; + ids = upstreamRowIds(epoch); + i = 0; + while (i < sizeof(ids)) { + m[ids[i]] = epoch; + i = i + 1; + } + return m; +} + +machine MUpstream { + var epochs: map[int, int]; // scope -> current epoch + + start state Serving { + entry { + epochs[0] = 1; + epochs[1] = 1; + } + + on eValidateReq do (p: (client: machine, scope: int, v: int)) { + send p.client, eValidateResp, (ok = p.v == epochs[p.scope], epoch = epochs[p.scope]); + } + + on eFetchReq do (p: (client: machine, scope: int, page: int)) { + var ids: seq[int]; + var rows: seq[tRow]; + var e: int; + e = epochs[p.scope]; + ids = upstreamRowIds(e); + if (p.page < sizeof(ids)) { + rows += (0, (id = ids[p.page], epoch = e, hops = 0, config = 0, stamp = -1)); + } + // Fixed 2-page rounds (pages per scope per round <= 2). + send p.client, eFetchResp, (rows = rows, epoch = e, morePages = p.page == 0); + } + + on eDiffReq do (p: (client: machine, scope: int, fromEpoch: int, page: int)) { + var e: int; + var ups: seq[tRow]; + var rms: seq[int]; + var fromIds: seq[int]; + var i: int; + e = epochs[p.scope]; + // Diff from base epoch to current: page 0 carries upserts + // (rows whose content changed), page 1 carries removes + // (ids present at base, absent now). Truthful and total. + if (p.page == 0) { + if (p.fromEpoch != e) { + ups += (0, (id = 0, epoch = e, hops = 0, config = 0, stamp = -1)); + } + } else { + fromIds = upstreamRowIds(p.fromEpoch); + i = 0; + while (i < sizeof(fromIds)) { + if (!(fromIds[i] in rowsAt(e))) { + rms += (sizeof(rms), fromIds[i]); + } + i = i + 1; + } + } + send p.client, eDiffResp, (upserts = ups, removes = rms, epoch = e, morePages = p.page == 0); + } + + on eMutate do (p: (client: machine, scope: int)) { + epochs[p.scope] = epochs[p.scope] + 1; + send p.client, eMutateAck; + } + } +} diff --git a/formal/walker/PSrc/Worker.p b/formal/walker/PSrc/Worker.p new file mode 100644 index 000000000..f2b9f0811 --- /dev/null +++ b/formal/walker/PSrc/Worker.p @@ -0,0 +1,782 @@ +/* MWorker: executes whole action chains page by page (syncOneAction's + whole-chain ownership, MODEL_SPEC 3). Each page's store ops commit + (acked) before the transition is reported; the worker then awaits + continue/abort, so a graceful stop aborts at page boundaries with + the current page's work committed (MODEL_SPEC 5). + + Scenario-1 connector policy (scripted, pure — MODEL_SPEC 9 case 1): + planning chain cursors: 0 = consult page (may spawn carrier [cell 1] + or replay inline [cell 1c]); 1 = re-consult page; 2,3 = fresh round + pages (fetch + upsert; publish on the last). Carrier actions + (hasAnnotation) run the MODEL_SPEC 4 replay page sequence. + + scopeLocks note: upsert pages are single atomic store ops (the + MODEL_SPEC 1 store abstraction), and no scenario-1 cell's verdict + depends on lock-excluded interleavings, so the lock itself is not + yet contended in this build; the toggle becomes load-bearing in the + case-4/7 cells (check-then-mark TOCTOU, leaked-lock retry). */ + +machine MWorker { + var scheduler: machine; + var store: machine; + var upstream: machine; + var gen: int; + var syncN: int; + var cfg: tScenarioCfg; + var warm: bool; + var g6: bool; // this attempt's source-cache capability bit (B1) + var aconfig: int; // this attempt's compat config (0 = unmodeled) + var action: tAction; + var hits: map[int, int]; + var replayedSnap: map[int, bool]; + var dead: bool; // this gen crashed; park (ops dropped, MODEL_SPEC 5) + var abortedMid: bool; // aborted at an in-page wait (lock grant) + var failedChain: bool; // attempt-level loud failure reported (P4 cells) + var warmFailUsed: bool; // the one-shot CO-6b-007 write-failure injection + // V-OVERLAY-UNIT volatile collect buffer (MODEL_SPEC 5 row): worker + // memory only, never checkpointed; buffer loss forces re-consult + // via the marker-absent resume rule (pin o-iv). + var ovFrom: int; + var ovTo: int; + var bufUp: seq[tRow]; + var bufRm: seq[int]; + // Case-7 reader: the session-derived stamp applied to this chain's + // fresh rows (-1 = the chain has no session derivation; 0 = miss). + var pageStamp: int; + + state Idle { + on eDispatch do (p: (action: tAction, hits: map[int, int], replayed: map[int, bool])) { + action = p.action; + hits = p.hits; + replayedSnap = p.replayed; + dead = false; + abortedMid = false; + failedChain = false; + warmFailUsed = false; + // Pin o-iv (V-OVERLAY-UNIT): the collect buffer is volatile, + // so cursor continuation without it is undefined; the model + // realizes the spec's transition-deferral pin (round-7 F1, + // CALIBRATION decision 21) as a reset to the consult page. + // Honest price: at-least-once re-fetch, lost work but never + // debris. The o4Mutant (MS-CO-001 F6 kill) REMOVES the + // reset: the resume honors the mid-chain cursor with an + // empty buffer and commits a unit missing the earlier + // pages' ops. + if (cfg.variant == VAR_OVERLAY_UNIT && action.cursor != 0 && !cfg.o4Mutant) { + action.cursor = 0; + } + // Scenario 8: the external op restarts from its root token + // on every (re)dispatch — a resumed external phase re-lists + // and re-reconciles rather than resuming a mid-phase + // cursor (restart-from-root is the healing mechanism + // deleteStaleExternalPrincipals is built for; a mid-phase + // cursor resume would copy a fresh answer over a stale + // reconciliation). + if (cfg.cell == 8 && action.cursor != 0) { + action.cursor = 0; + } + bufUp = default(seq[tRow]); + bufRm = default(seq[int]); + pageStamp = -1; + runChain(); + } + // A stale abort can reach an idle worker when its last + // transition raced the stop; nothing to roll back. + ignore eAbortWorker; + } + + fun runChain() { + var res: (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int); + var aborted: bool; + aborted = false; + while (!aborted) { + res = execPage(); + if (dead) { return; } + // Attempt-level loud failure: eChainFailed already sent; + // no transition — the scheduler restores the action at the + // offending cursor and quiesces the attempt. + if (failedChain) { return; } + if (abortedMid) { + send scheduler, eWorkerAborted, (aid = action.aid, cursor = action.cursor); + return; + } + send scheduler, eActionTransition, (aid = action.aid, nextCursor = res.nextCursor, done = res.done, spawn = res.spawn, hasSpawn = res.hasSpawn, hitScope = res.hitScope, hitV = res.hitV, hasHit = res.hasHit, markReplayed = res.markReplayed, replayedScope = res.replayedScope); + if (res.done) { return; } + receive { + case eContinuePage: { + action.cursor = res.nextCursor; + } + case eAbortWorker: { + send scheduler, eWorkerAborted, (aid = action.aid, cursor = res.nextCursor); + aborted = true; + } + } + } + } + + // Executes the page at action.cursor; returns the transition. + fun execPage(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + // C1-probe shape (MODEL_SPEC 9.5 C1, cell 53): ONE action whose + // policy places the replay annotation MID-CHAIN — page 0 + // consults (hit recorded at lookup), page 1 is the annotated + // replay page, pages 2+ are the fresh chain (consult miss / + // revalidation failure). A stop between pages 0 and 1 + // checkpoints the mid-chain cursor + the hit map; the resumed + // page 1 performs NO fresh consult and the hit check passes on + // the RESTORED map — the C1Probe monitor's red is exactly that + // witness. + if (cfg.cell == 53) { + if (action.cursor == 0) { + return c1ConsultPage(); + } + if (action.cursor == 1) { + return replayPage(action.annotationV, action.publishes, action.aid * 100, false, -1); + } + return freshPage(); + } + if (action.hasAnnotation) { + return replayPage(action.annotationV, action.publishes, action.aid * 100, false, -1); + } + if (cfg.cell == 2 || cfg.cell == 21) { + return sessionPage(); + } + if (cfg.cell == 8) { + return extPage(); + } + if (cfg.cell == 7 && (action.cursor == 0 || action.cursor == 1)) { + return kindPage7(); + } + if (action.cursor >= 4) { + return overlayPage(); + } + if (action.cursor == 0 || action.cursor == 1) { + return consultPage(); + } + return freshPage(); + } + + // Case-7 kind chains (sessions x replay, MODEL_SPEC 9.7). Kind = + // (op, scope): W = scope 0 (producer), R = scope 1 (reader); the + // env roots them with DIFFERENT ops so batching runs the phases + // sequentially. Page 0 consults the kind's own scope: + // - valid hit (and, for R, an opted-in policy): warm replay INLINE + // (shipped carrier-less path). ELISION IS STRUCTURAL: the fresh + // enumeration — and W's session write inside it — never runs. + // - otherwise fetch-fresh: W writes K = f(this sync's epoch) as the + // enumeration side effect; R reads K and stamps its fresh rows + // with the read value (0 = read-miss); chains continue on the + // shared fresh pages (cursors 2, 3). + fun kindPage7(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var hit: bool; + var v: int; + var ok: bool; + var e: int; + var found: bool; + var val: int; + send store, eLookupReq, (client = this, gen = gen, scope = action.scope); + receive { + case eLookupResp: (r: (hit: bool, v: int)) { + hit = r.hit; + v = r.v; + } + case eStoreDead: { dead = true; } + } + if (dead) { return mkTransition(0, true, false, -1, false); } + ok = false; + e = -1; + if (hit) { + hits[action.scope] = v; + send upstream, eValidateReq, (client = this, scope = action.scope, v = v); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { + ok = r.ok; + e = r.epoch; + } + } + } + announce eAnnConsult, (syncN = syncN, scope = action.scope, hit = hit, v = v, validated = ok, epoch = e, freshFetch = false, diffVerdict = false, attempt = gen); + if (hit && ok && !(action.scope == 1 && cfg.readerAlwaysFresh)) { + return replayPage(v, true, action.aid * 100, true, v); + } + if (action.scope == 0) { + // W fresh: the session write is part of the producer's + // enumeration phase (side effect, op-commit durable). + send upstream, eFetchReq, (client = this, scope = action.scope, page = 0); + receive { + case eFetchResp: (r: (rows: seq[tRow], epoch: int, morePages: bool)) { e = r.epoch; } + } + send store, eSessionSet, (client = this, gen = gen, scope = action.scope, key = 0, val = e, taint = cfg.toggles.sessionTaintWrites || cfg.toggles.sessionTaintAll); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + return mkTransition(2, false, hit, v, false); + } + // R fresh: derive the row stamp from the session read (0 = miss). + send store, eSessionGetReq, (client = this, gen = gen, scope = action.scope, key = 0, taint = cfg.toggles.sessionTaintAll); + receive { + case eSessionGetResp: (r: (found: bool, val: int)) { + found = r.found; + val = r.val; + } + case eStoreDead: { dead = true; } + } + if (dead) { return mkTransition(0, true, false, -1, false); } + if (found) { + pageStamp = val; + } else { + pageStamp = 0; + } + return mkTransition(2, false, hit, v, false); + } + + // Case-2 connector policies (session laundering, MODEL_SPEC 9.2). + // H (aid 1): 2-page writer; EACH page derives from upstream and + // writes the session key (op-commit durable) — a mid-chain resume + // re-derives on its remaining pages. G (aid 2): 1-page reader; + // reads the session key and emits a row EMBEDDING the read value. + // A read-miss emits nothing (the reader consumes a value the writer + // produced; absent key = nothing to embed), so read-before-write + // races don't manufacture alarms outside the laundering premise. + fun sessionPage(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var e: int; + var found: bool; + var val: int; + var rows: seq[tRow]; + var ghost: tRoundGhost; + if (action.aid == 1) { + send upstream, eFetchReq, (client = this, scope = action.scope, page = 0); + receive { + case eFetchResp: (r: (rows: seq[tRow], epoch: int, morePages: bool)) { e = r.epoch; } + } + send store, eSessionSet, (client = this, gen = gen, scope = action.scope, key = 0, val = e, taint = cfg.toggles.sessionTaintWrites || cfg.toggles.sessionTaintAll); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + if (action.cursor == 0) { + return mkTransition(1, false, false, -1, false); + } + return mkTransition(0, true, false, -1, false); + } + send store, eSessionGetReq, (client = this, gen = gen, scope = action.scope, key = 0, taint = cfg.toggles.sessionTaintAll); + receive { + case eSessionGetResp: (r: (found: bool, val: int)) { + found = r.found; + val = r.val; + } + case eStoreDead: { dead = true; } + } + if (dead) { return mkTransition(0, true, false, -1, false); } + if (!found) { + return mkTransition(0, true, false, -1, false); + } + ghost = (roundId = action.aid * 100, verdict = V_FRESH, consultEpoch = 0, config = 0, lastOp = true, attempt = gen); + rows += (0, (id = 1, epoch = 0, hops = 0, config = 0, stamp = val)); + send store, eUpsertPage, (client = this, gen = gen, scope = action.scope, rows = rows, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return mkTransition(0, true, false, -1, false); + } + + // Scenario-8 external phase (MODEL_SPEC abstraction of + // SyncExternalResources; cell 8). Page 0 = LIST + RECONCILE: read + // the external source's current answer (the truthful epoch table — + // the extStaleList mutant lists the sync-start epoch on attempts + // >= 2 instead, the recency bug ResumeUsesCurrentExternalAnswer + // pins) and commit the reconciliation op (delete-stale under + // cfg.extRecon; warn-and-continue degrade otherwise). Page 1 = + // COPY: commit the listed answer's principal writes. Crash windows + // exist at every op boundary; a resumed phase restarts from page 0 + // (the eDispatch reset above). + fun extPage(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var e: int; + var live: seq[int]; + send upstream, eValidateReq, (client = this, scope = action.scope, v = -1); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { e = r.epoch; } + } + if (cfg.extStaleList && gen % 10 >= 2) { + // The recency mutant: the resumed attempt consumes the dead + // attempt's answer instead of re-listing. + e = 1; + } + live = upstreamRowIds(e); + if (action.cursor == 0) { + send store, eExtReconReq, (client = this, gen = gen, live = live, supported = cfg.extRecon); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + return mkTransition(1, false, false, -1, false); + } + send store, eExtCopy, (client = this, gen = gen, ids = live); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return mkTransition(0, true, false, -1, false); + } + + // C1-probe page 0: consult and CONTINUE mid-chain (no spawn, no + // inline replay). Hit + valid -> the annotated replay page (cursor + // 1); miss or revalidation failure -> the fresh chain (cursor 2). + // Hit recording is pinned at lookup time as everywhere. + fun c1ConsultPage(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var hit: bool; + var v: int; + var ok: bool; + var e: int; + send store, eLookupReq, (client = this, gen = gen, scope = action.scope); + receive { + case eLookupResp: (r: (hit: bool, v: int)) { + hit = r.hit; + v = r.v; + } + case eStoreDead: { dead = true; } + } + if (dead) { return mkTransition(0, true, false, -1, false); } + ok = false; + e = -1; + if (hit) { + send upstream, eValidateReq, (client = this, scope = action.scope, v = v); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { + ok = r.ok; + e = r.epoch; + } + } + } + announce eAnnConsult, (syncN = syncN, scope = action.scope, hit = hit, v = v, validated = ok, epoch = e, freshFetch = false, diffVerdict = false, attempt = gen); + if (hit && ok) { + return mkTransition(1, false, true, v, false); + } + return mkTransition(2, false, hit, v, false); + } + + fun consultPage(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var hit: bool; + var v: int; + var ok: bool; + var e: int; + var carrier: tAction; + var marked: bool; + var willDiff: bool; + var ghost: tRoundGhost; + var rp: (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int); + // Cold attempt (warm install failed at attempt start): no + // source-cache lookup exists — the connector adapts cold and + // fetches fresh (CO-6b-005 shape). No hit is recorded. + if (!warm && (cfg.cell == 51 || cfg.cell == 52)) { + return mkTransition(2, false, false, -1, false); + } + // Scenario-6 variants: the marker check precedes the consult + // (clause iii). A marked scope's work completed this sync; + // re-consult and re-derivation are suppressed. + if (cfg.variant != VAR_SHIPPED && action.cursor == 0) { + send store, eMarkerReadReq, (client = this, gen = gen, scope = action.scope); + receive { + case eMarkerReadResp: (r: (marked: bool)) { marked = r.marked; } + case eStoreDead: { dead = true; } + } + if (dead) { return mkTransition(0, true, false, -1, false); } + if (marked) { + return mkTransition(0, true, false, -1, false); + } + } + send store, eLookupReq, (client = this, gen = gen, scope = action.scope); + receive { + case eLookupResp: (r: (hit: bool, v: int)) { + hit = r.hit; + v = r.v; + } + case eStoreDead: { dead = true; } + } + if (dead) { return mkTransition(0, true, false, -1, false); } + ok = false; + e = -1; + if (hit) { + // Hit recording is pinned at lookup-hit time, before and + // regardless of the revalidation outcome (MODEL_SPEC 3). + hits[action.scope] = v; + send upstream, eValidateReq, (client = this, scope = action.scope, v = v); + receive { + case eValidateResp: (r: (ok: bool, epoch: int)) { + ok = r.ok; + e = r.epoch; + } + } + } + // Changed-with-diff verdict (overlay flavors): the diff-based + // consult counts as consulted-against-upstream (round-5 P2 pin). + willDiff = hit && !ok && (cfg.variant == VAR_OVERLAY_NAIVE || cfg.variant == VAR_OVERLAY_UNIT || cfg.variant == VAR_OVERLAY_LAST); + announce eAnnConsult, (syncN = syncN, scope = action.scope, hit = hit, v = v, validated = ok, epoch = e, freshFetch = false, diffVerdict = willDiff, attempt = gen); + if (!hit) { + // No previous artifact surface: fetch-fresh. + return mkTransition(2, false, false, -1, false); + } + if (ok) { + if (cfg.variant != VAR_SHIPPED) { + // Variants replay INLINE on the consulting page — no + // carrier spawn exists (V-ATOMIC clause i; V-NAIVE + // shares the inline shape, differing only in commit + // structure). + return variantReplay(v); + } + if (action.cursor == 0 && cfg.cell == 1) { + // Verdict replay: spawn a same-op carrier with the + // replay annotation in its token; chain continues. + carrier = (aid = action.aid + 100, op = action.op, scope = action.scope, cursor = 0, hasAnnotation = true, annotationV = v, publishes = cfg.carrierPublishes); + return (nextCursor = 1, done = false, spawn = carrier, hasSpawn = true, hitScope = action.scope, hitV = v, hasHit = true, markReplayed = false, replayedScope = -1); + } + if (action.cursor == 0 && (cfg.cell == 31 || cfg.cell == 51 || cfg.cell == 52)) { + // Case-3B/5 shape: 1-page planning — consult, spawn the + // carrier, and POP (done at the stop checkpoint). No + // re-consult page exists; the hit map keeps V_A. + carrier = (aid = action.aid + 100, op = action.op, scope = action.scope, cursor = 0, hasAnnotation = true, annotationV = v, publishes = cfg.carrierPublishes); + return (nextCursor = 0, done = true, spawn = carrier, hasSpawn = true, hitScope = action.scope, hitV = v, hasHit = true, markReplayed = false, replayedScope = -1); + } + if (action.cursor == 0 && cfg.cell == 4) { + // Scenario 4: first of two duplicate carriers — + // byte-distinct tokens (distinct aids) encoding the + // same (scope, verdict), dodging spawn dedup. + carrier = (aid = action.aid + 100, op = action.op, scope = action.scope, cursor = 0, hasAnnotation = true, annotationV = v, publishes = cfg.carrierPublishes); + return (nextCursor = 1, done = false, spawn = carrier, hasSpawn = true, hitScope = action.scope, hitV = v, hasHit = true, markReplayed = false, replayedScope = -1); + } + if (action.cursor == 1 && cfg.cell == 4) { + // Second duplicate carrier; chain ends. + carrier = (aid = action.aid + 200, op = action.op, scope = action.scope, cursor = 0, hasAnnotation = true, annotationV = v, publishes = cfg.carrierPublishes); + return (nextCursor = 0, done = true, spawn = carrier, hasSpawn = true, hitScope = action.scope, hitV = v, hasHit = true, markReplayed = false, replayedScope = -1); + } + if (action.cursor == 0 && cfg.cell == 3) { + // Carrier-less variant (1c): replay inline on the + // consulting page itself; no spawn, no stop needed. + rp = replayPage(v, true, action.aid * 100, true, v); + return rp; + } + // Re-consult page (cursor 1): still valid, nothing new. + return mkTransition(0, true, true, v, false); + } + if (willDiff) { + ovFrom = v; + ovTo = e; + if (cfg.variant == VAR_OVERLAY_NAIVE) { + // THE MISDRAW (6-overlay-naive): the unit {clear, copy, + // marker, publish(V_to)} commits at the CONSULT + // boundary; overlay pages follow per-page. The round is + // NOT complete here (lastOp waits for the final overlay + // page), but the marker and post-diff validator are + // already durable. + ghost = (roundId = action.aid * 100, verdict = V_OVERLAY, consultEpoch = e, config = 0, lastOp = false, attempt = gen); + send store, eReplayUnit, (client = this, gen = gen, scope = action.scope, v = e, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + } + if (cfg.variant == VAR_OVERLAY_LAST) { + // THE THIRD PLACEMENT (6-overlay-last, round-7 F2): no + // unit anywhere — clear and copy commit as two separate + // per-page ops at the replay boundary; marker+publish + // trail LAST (see overlayPage). A crash before the + // marker leaves unmarked debris that the re-verdict's + // own clear WIPES (no reduction to 6-naive's union). + ghost = (roundId = action.aid * 100, verdict = V_OVERLAY, consultEpoch = e, config = 0, lastOp = false, attempt = gen); + send store, eClearScope, (client = this, gen = gen, scope = action.scope, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + send store, eCopyScope, (client = this, gen = gen, scope = action.scope, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + } + // V-OVERLAY-UNIT: no store op commits at consult; the + // collect starts (pin o-ii). + return mkTransition(4, false, true, v, false); + } + // Revalidation failed: verdict fetch-fresh; chain continues + // with the fresh round (hit stays recorded — last-write-wins). + return mkTransition(2, false, true, v, false); + } + + // Overlay pages (cursors 4, 5): diff collection. V-OVERLAY-UNIT + // buffers pages and commits ONE eOverlayUnit at the final page + // (pins o-i/o-ii/o-iii); the naive misdraw commits per-page via the + // shipped path (upserts, then tombstones with the round's lastOp). + fun overlayPage(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var page: int; + var ups: seq[tRow]; + var rms: seq[int]; + var more: bool; + var i: int; + var ghost: tRoundGhost; + page = action.cursor - 4; + send upstream, eDiffReq, (client = this, scope = action.scope, fromEpoch = ovFrom, page = page); + receive { + case eDiffResp: (r: (upserts: seq[tRow], removes: seq[int], epoch: int, morePages: bool)) { + ups = r.upserts; + rms = r.removes; + more = r.morePages; + } + } + if (cfg.variant == VAR_OVERLAY_UNIT) { + i = 0; + while (i < sizeof(ups)) { bufUp += (sizeof(bufUp), ups[i]); i = i + 1; } + i = 0; + while (i < sizeof(rms)) { bufRm += (sizeof(bufRm), rms[i]); i = i + 1; } + if (more) { + return mkTransition(action.cursor + 1, false, false, -1, false); + } + ghost = (roundId = action.aid * 100, verdict = V_OVERLAY, consultEpoch = ovTo, config = 0, lastOp = true, attempt = gen); + send store, eOverlayUnit, (client = this, gen = gen, scope = action.scope, v = ovTo, upserts = bufUp, removes = bufRm, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return mkTransition(0, true, false, -1, false); + } + // Naive and third-placement: per-page commits on the shipped path. + if (more) { + ghost = (roundId = action.aid * 100, verdict = V_OVERLAY, consultEpoch = ovTo, config = 0, lastOp = false, attempt = gen); + send store, eUpsertPage, (client = this, gen = gen, scope = action.scope, rows = ups, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return mkTransition(action.cursor + 1, false, false, -1, false); + } + if (cfg.variant == VAR_OVERLAY_LAST) { + // Third placement's tail: tombstones are NOT the round's + // last prescribed op — marker and publish(V_to) trail as + // two separate queue positions. w2 = a crash between them: + // marked, entry-less, content-complete; clause (iii) + // suppresses the re-execution and the scope seals with an + // EMPTY fold (publish never committed) — the P1 witness. + ghost = (roundId = action.aid * 100, verdict = V_OVERLAY, consultEpoch = ovTo, config = 0, lastOp = false, attempt = gen); + send store, eTombstonePage, (client = this, gen = gen, scope = action.scope, removes = rms, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + send store, eMarkerPut, (client = this, gen = gen, scope = action.scope); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + ghost = (roundId = action.aid * 100, verdict = V_OVERLAY, consultEpoch = ovTo, config = 0, lastOp = true, attempt = gen); + send store, ePublishEntry, (client = this, gen = gen, scope = action.scope, v = ovTo, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return mkTransition(0, true, false, -1, false); + } + ghost = (roundId = action.aid * 100, verdict = V_OVERLAY, consultEpoch = ovTo, config = 0, lastOp = true, attempt = gen); + send store, eTombstonePage, (client = this, gen = gen, scope = action.scope, removes = rms, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return mkTransition(0, true, false, -1, false); + } + + fun freshPage(): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var rows: seq[tRow]; + var e: int; + var more: bool; + var page: int; + var i: int; + var r2: tRow; + var ghost: tRoundGhost; + page = action.cursor - 2; + send upstream, eFetchReq, (client = this, scope = action.scope, page = page); + receive { + case eFetchResp: (r: (rows: seq[tRow], epoch: int, morePages: bool)) { + rows = r.rows; + e = r.epoch; + more = r.morePages; + } + } + // Session-derived chains (case-7 reader) stamp their fresh rows + // with the value read in the derivation phase; config-modeled + // cells (case 5) tag fresh rows with this attempt's compat + // config (the P1 clause-c ghost). + if (pageStamp != -1 || aconfig != 0) { + i = 0; + while (i < sizeof(rows)) { + r2 = rows[i]; + if (pageStamp != -1) { r2.stamp = pageStamp; } + r2.config = aconfig; + rows[i] = r2; + i = i + 1; + } + } + announce eAnnConsult, (syncN = syncN, scope = action.scope, hit = false, v = -1, validated = false, epoch = e, freshFetch = true, diffVerdict = false, attempt = gen); + ghost = (roundId = action.aid * 100 + 2, verdict = V_FRESH, consultEpoch = e, config = aconfig, lastOp = false, attempt = gen); + send store, eUpsertPage, (client = this, gen = gen, scope = action.scope, rows = rows, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (more) { + return mkTransition(action.cursor + 1, false, false, -1, false); + } + // Last fresh page: publish the new validator (epoch-valued, + // truthful); publish is the round's last prescribed op. + ghost = (roundId = action.aid * 100 + 2, verdict = V_FRESH, consultEpoch = e, config = aconfig, lastOp = true, attempt = gen); + send store, ePublishEntry, (client = this, gen = gen, scope = action.scope, v = e, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return mkTransition(0, true, false, -1, false); + } + + // MODEL_SPEC 4 replay page sequence. inline = the 1c shape (consult + // and replay on one page; the hit was recorded this page). + fun replayPage(vAnn: int, publishes: bool, roundId: int, inline: bool, inlineHitV: int): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var ghost: tRoundGhost; + var baseV: int; + var basePresent: bool; + var doCopy: bool; + var hitHas: bool; + var hitNow: int; + // B1 (MODEL_SPEC 4): a replay-annotated page arriving in an + // attempt WITHOUT source-cache handling is SILENTLY IGNORED — + // no-op page ops, no failure, no announce, no marks. Precedes + // every gate (the page ops are nil, so no gate ever evaluates). + // The 5b scripted seal-state expectation is this path's oracle. + if (!g6) { + return mkTransition(0, true, false, -1, false); + } + // warm-gate check (toggle: warmGate): a cold attempt's replay + // page fails LOUD — announced, chain ends cold, no ops (the 5a + // mitigation's success path; behavior, not an assert, because + // scripted drift configs reach this gate legitimately). In P4 + // cells the loud failure fails the ATTEMPT (MODEL_SPEC 4). + if (cfg.toggles.warmGate && !warm) { + announce eAnnLoudCold, (syncN = syncN, scope = action.scope, reason = 2); + if (cfg.loudColdFailsAttempt) { + failedChain = true; + send scheduler, eChainFailed, (aid = action.aid, cursor = action.cursor, scope = action.scope, reason = 2); + } + return mkTransition(0, true, false, -1, false); + } + // hit check (B5 provenance; loud cold on absence). The hit map + // is ONE sync-level structure, recorded at lookup time, + // last-write-wins — so the carrier reads it LIVE at drain time + // (a re-consult in the same attempt may have overwritten it; + // the case-3A rebind hole is this read seeing the overwrite). + if (inline) { + hitHas = true; + hitNow = inlineHitV; + } else { + send scheduler, eHitReadReq, (worker = this, scope = action.scope); + receive { + case eHitReadResp: (r: (has: bool, v: int)) { + hitHas = r.has; + hitNow = r.v; + } + case eAbortWorker: { abortedMid = true; } + } + if (abortedMid) { return mkTransition(0, true, false, -1, false); } + } + assert hitHas, "unmodeled loud-cold: replay without recorded hit"; + // oncePerScope check-and-mark. Locks ON: the grant carries the + // replayed status and the release commits the mark — atomic + // check-then-mark. Locks OFF: lock-free read here, mark lands + // at the action transition — the case-4 TOCTOU window. + doCopy = true; + if (cfg.toggles.scopeLocks) { + send scheduler, eScopeLockAcquire, (worker = this, scope = action.scope); + receive { + case eScopeLockGrant: (g: (replayed: bool)) { + if (cfg.toggles.oncePerScope && g.replayed) { doCopy = false; } + } + case eAbortWorker: { abortedMid = true; } + } + if (abortedMid) { return mkTransition(0, true, false, -1, false); } + } else { + send scheduler, eReplayedCheckReq, (worker = this, scope = action.scope); + receive { + case eReplayedCheckResp: (r: (replayed: bool)) { + if (cfg.toggles.oncePerScope && r.replayed) { doCopy = false; } + } + } + } + // CO-6b-007 premise: ONE injected destination-write failure + // after the scope lock is acquired; the worker retries the + // action IN-ATTEMPT (mirrors syncOneAction's retry loop), + // re-entering the page sequence from the top. With the + // release-on-error edge present (shipped) the retry re-acquires + // cleanly and the page completes; with the edge REMOVED (the + // model's mutation check) the retry blocks forever on its own + // leaked lock — the hang surfaces as a checker deadlock. + if (cfg.warmPageFails && !warmFailUsed) { + warmFailUsed = true; + if (cfg.lockReleaseOnError && cfg.toggles.scopeLocks) { + send scheduler, eScopeLockRelease, (scope = action.scope, mark = false); + } + return replayPage(vAnn, publishes, roundId, inline, inlineHitV); + } + if (doCopy) { + if (cfg.toggles.hitValidatorBinding) { + send store, eBaseReadReq, (client = this, gen = gen, scope = action.scope); + receive { + case eBaseReadResp: (r: (v: int, present: bool)) { + baseV = r.v; + basePresent = r.present; + } + case eStoreDead: { dead = true; } + } + if (dead) { return mkTransition(0, true, false, -1, false); } + if (!basePresent || baseV != hitNow) { + // Loud cold (CO-6b-004 kill): the binding gate + // detects a base the recorded hit did not attest; + // the chain fails cold — no copy, no publish, no + // wrong data. Behavior, not an assert: scenario-3 + // schedules reach this gate legitimately and green. + // In P4 cells the loud failure fails the ATTEMPT. + announce eAnnLoudCold, (syncN = syncN, scope = action.scope, reason = 1); + if (cfg.toggles.scopeLocks) { + send scheduler, eScopeLockRelease, (scope = action.scope, mark = false); + } + if (cfg.loudColdFailsAttempt) { + failedChain = true; + send scheduler, eChainFailed, (aid = action.aid, cursor = action.cursor, scope = action.scope, reason = 1); + } + return mkTransition(0, true, false, -1, false); + } + } + ghost = (roundId = roundId, verdict = V_REPLAY, consultEpoch = vAnn, config = aconfig, lastOp = false, attempt = gen); + send store, eClearScope, (client = this, gen = gen, scope = action.scope, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + ghost = (roundId = roundId, verdict = V_REPLAY, consultEpoch = vAnn, config = aconfig, lastOp = !publishes, attempt = gen); + send store, eCopyScope, (client = this, gen = gen, scope = action.scope, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + } + if (cfg.toggles.scopeLocks) { + send scheduler, eScopeLockRelease, (scope = action.scope, mark = doCopy); + } + if (publishes) { + // A copy-skipped replacement round's publish still runs + // (MODEL_SPEC 4: ePublishEntry even on a copy-skipped page). + ghost = (roundId = roundId, verdict = V_REPLAY, consultEpoch = vAnn, config = aconfig, lastOp = true, attempt = gen); + send store, ePublishEntry, (client = this, gen = gen, scope = action.scope, v = vAnn, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + } + return (nextCursor = 0, done = true, spawn = default(tAction), hasSpawn = false, hitScope = action.scope, hitV = hitNow, hasHit = inline, markReplayed = doCopy, replayedScope = action.scope); + } + + // Scenario-6 replay-with-marker, inline on the consulting page. + // V-NAIVE: shipped steps with the marker as a SEPARATE op after + // eCopyScope (clear, copy, marker, publish — four queue positions; + // a crash can land between any two). V-ATOMIC: one eReplayUnit op. + fun variantReplay(v: int): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + var ghost: tRoundGhost; + if (cfg.variant == VAR_ATOMIC || cfg.variant == VAR_OVERLAY_NAIVE || cfg.variant == VAR_OVERLAY_UNIT) { + ghost = (roundId = action.aid * 100, verdict = V_REPLAY, consultEpoch = v, config = 0, lastOp = true, attempt = gen); + send store, eReplayUnit, (client = this, gen = gen, scope = action.scope, v = v, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return (nextCursor = 0, done = true, spawn = default(tAction), hasSpawn = false, hitScope = action.scope, hitV = v, hasHit = true, markReplayed = true, replayedScope = action.scope); + } + ghost = (roundId = action.aid * 100, verdict = V_REPLAY, consultEpoch = v, config = 0, lastOp = false, attempt = gen); + send store, eClearScope, (client = this, gen = gen, scope = action.scope, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + send store, eCopyScope, (client = this, gen = gen, scope = action.scope, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + send store, eMarkerPut, (client = this, gen = gen, scope = action.scope); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + if (dead) { return mkTransition(0, true, false, -1, false); } + ghost = (roundId = action.aid * 100, verdict = V_REPLAY, consultEpoch = v, config = 0, lastOp = true, attempt = gen); + send store, ePublishEntry, (client = this, gen = gen, scope = action.scope, v = v, ghost = ghost); + receive { case eStoreAck: {} case eStoreDead: { dead = true; } } + return (nextCursor = 0, done = true, spawn = default(tAction), hasSpawn = false, hitScope = action.scope, hitV = v, hasHit = true, markReplayed = true, replayedScope = action.scope); + } + + fun mkTransition(next: int, done: bool, hasHit: bool, hitV: int, markReplayed: bool): (nextCursor: int, done: bool, spawn: tAction, hasSpawn: bool, hitScope: int, hitV: int, hasHit: bool, markReplayed: bool, replayedScope: int) { + return (nextCursor = next, done = done, spawn = default(tAction), hasSpawn = false, hitScope = action.scope, hitV = hitV, hasHit = hasHit, markReplayed = markReplayed, replayedScope = action.scope); + } + + start state Boot { + entry (p: (scheduler: machine, store: machine, upstream: machine, gen: int, syncN: int, cfg: tScenarioCfg, warm: bool, g6: bool, aconfig: int)) { + scheduler = p.scheduler; + store = p.store; + upstream = p.upstream; + gen = p.gen; + syncN = p.syncN; + cfg = p.cfg; + warm = p.warm; + g6 = p.g6; + aconfig = p.aconfig; + goto Idle; + } + } +} diff --git a/formal/walker/PTst/Scenario1.p b/formal/walker/PTst/Scenario1.p new file mode 100644 index 000000000..f148cbd89 --- /dev/null +++ b/formal/walker/PTst/Scenario1.p @@ -0,0 +1,122 @@ +/* Scenario 1 — phantom union (MODEL_SPEC 9 case 1). + Shipped toggles ON in every cell: the residual exists in the shipped + design. Expected verdicts: + - tc1a1b_P1 (stop-stranding, carrier publishes, 2 syncs): P1-CONTENT + red on 1a schedules (carrier drains between/before fresh pages). + - tc1a1b_P3: P3'-COHERENCE red on 1b-i schedules (carrier drains + after the complete fresh round; content green, epoch incoherent). + - tc1a1b_P2 (3 syncs, corollary-run scoping): P2-STALENESS red on + the verification sync — the union replays warm, hops reach 2 + (the unbounded branch). + - tc1bii_P1 (carrier validator-less): P1 red; the attestation-only + edge (entry V2 over folded rows(e1)) is among the violations. + - tc1c_P1/tc1c_P2 (carrier-less hard crash): P1-CONTENT red with one + crash and no replay in attempt 2; P2 red on the verification sync. + - tcGreen_All (no interruption, no mutation, 2 syncs incl. one + honest replay): all monitors green — the abstraction sanity + control. */ + +fun shippedToggles(): tToggles { + return (warmGate = true, hitValidatorBinding = true, scopeLocks = true, oncePerScope = true, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = false); +} + +machine Test1a { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 1; + c.interrupt = 1; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test1aVerify { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 1; + c.interrupt = 1; + c.mutateBetweenAttempts = true; + c.nSyncs = 3; + c.verificationOnlyIfInterrupted = true; + new MEnv(c); + } + } +} + +machine Test1bii { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 1; + c.interrupt = 1; + c.mutateBetweenAttempts = true; + c.carrierPublishes = false; + new MEnv(c); + } + } +} + +machine Test1c { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 1; + c.cell = 3; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test1cVerify { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 1; + c.cell = 3; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.nSyncs = 3; + c.verificationOnlyIfInterrupted = true; + new MEnv(c); + } + } +} + +machine TestGreen { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 1; + new MEnv(c); + } + } +} + +module Walker = { MEnv, MStore, MUpstream, MSyncAttempt, MWorker }; + +// Expected RED (counterexample = the calibration find): +test tc1a1b_P1 [main=Test1a]: assert P1 in (union Walker, { Test1a }); +test tc1a1b_P3 [main=Test1a]: assert P3prime in (union Walker, { Test1a }); +test tc1a1b_P2 [main=Test1aVerify]: assert P2 in (union Walker, { Test1aVerify }); +test tc1bii_P1 [main=Test1bii]: assert P1 in (union Walker, { Test1bii }); +test tc1c_P1 [main=Test1c]: assert P1 in (union Walker, { Test1c }); +test tc1c_P2 [main=Test1cVerify]: assert P2 in (union Walker, { Test1cVerify }); + +// Expected GREEN (sanity controls): +test tcGreen_All [main=TestGreen]: assert P1, P2, P3prime in (union Walker, { TestGreen }); +// The P1/P3 cells must also hold P1 green where their premise implies +// no alarm; P2's corollary config must stay green in honest histories. +test tc1c_P2_honest [main=Test1c]: assert P2 in (union Walker, { Test1c }); +// Probe: the verify config must still contain the sync-2 union premise. +test tc1c_P1_probe [main=Test1cVerify]: assert P1 in (union Walker, { Test1cVerify }); diff --git a/formal/walker/PTst/Scenario2.p b/formal/walker/PTst/Scenario2.p new file mode 100644 index 000000000..8a2d7fd89 --- /dev/null +++ b/formal/walker/PTst/Scenario2.p @@ -0,0 +1,149 @@ +/* Scenario 2 — session laundering (MODEL_SPEC 9 case 2, P6-A). + One sync, two same-op actions on the root stack: H (aid 1) writes + the session key with a value derived from upstream on EACH of its + two pages; G (aid 2) reads the key and emits a row embedding the + read value. Sessions variant A (shipped): the session KV is durable + at op commit and survives attempts; committed rows are never + invalidated by later session writes. Both red cells are EXPECTED + FINDINGS (no fix run — variant B is the graph addendum's + obligation). Expected verdicts: + - tc2stop_P6A (graceful stop, upstream mutated between attempts): + RED — the schedule where H's d1 write commits, G reads d1, emits, + and finishes, then the stop strands H mid-chain; H alone re-runs + and derives d2; G's committed row embeds d1 != final d2. + - tc2crash_P6A (hard crash, at-least-once): RED — both re-run from + root; the interleaving where G re-reads the DURABLE stale d1 + before H's re-derivation lands re-commits the d1 embed under a + final d2. The complementary interleaving (H re-derives first, G + embeds d2) is green — both outcomes live in this one config. + - tc2green_P6A (no interruption, no mutation): GREEN — the reader + embeds what the writer wrote; a read-miss emits nothing. */ + +machine Test2Stop { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 2; + c.cell = 2; + c.interrupt = 1; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test2Crash { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 2; + c.cell = 2; + c.interrupt = 2; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test2Green { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 2; + c.cell = 2; + c.nSyncs = 1; + new MEnv(c); + } + } +} + +// P6-C cells (session-checkpoint consistency — the CO-6b-009 root +// cause). Same crash chassis as Test2Crash; the axis is +// cfg.sessVariant (the store's session semantics at the crash +// boundary). All three variants of the conversation are cells: +// - variant 0 (shipped, durable-at-op-commit): expected RED on +// P6-C-ZOMBIE — H's beyond-checkpoint d1 survives the crash and +// the re-run G reads it before H's re-derivation lands. +// - variant 1 (the REJECTED wholesale resume-clear): expected RED +// on P6-C-AMNESIA — a checkpoint-committed d1 is destroyed and +// G's re-read misses data whose producing work will not re-run. +// - variant 2 (checkpoint-consistent sessions — the correct fix, +// future work per CO-6b-009): expected GREEN, both directions. + +machine Test2CrashP6C { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 2; + c.cell = 2; + c.interrupt = 2; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +// The amnesia and fix cells run cell 21 (root order REVERSED: the +// writer pops first). In cell 2 the reader G pops first under LIFO, +// so every checkpoint that still contains G predates H's writes — a +// checkpoint-COMMITTED session value with a reader re-run ahead of it +// (the amnesia premise) is structurally unreachable there. Verified: +// tc2clear_P6C on cell 2 is green at 10k schedules for exactly this +// reason, not because the rejected fix is sound. +machine Test2ClearP6C { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 2; + c.cell = 21; + c.interrupt = 2; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + c.sessVariant = 1; + new MEnv(c); + } + } +} + +machine Test2ConsistentP6C { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 2; + c.cell = 21; + c.interrupt = 2; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + c.sessVariant = 2; + new MEnv(c); + } + } +} + +// Expected RED (both are design findings of sessions variant A): +test tc2stop_P6A [main=Test2Stop]: assert P6A in (union Walker, { Test2Stop }); +test tc2crash_P6A [main=Test2Crash]: assert P6A in (union Walker, { Test2Crash }); + +// Expected GREEN: +test tc2green_P6A [main=Test2Green]: assert P6A in (union Walker, { Test2Green }); + +// P6-C cells. Expected RED (shipped zombie; rejected-fix amnesia): +test tc2crash_P6C [main=Test2CrashP6C]: assert P6C in (union Walker, { Test2CrashP6C }); +test tc2clear_P6C [main=Test2ClearP6C]: assert P6C in (union Walker, { Test2ClearP6C }); + +// Expected GREEN (checkpoint-consistent sessions close both directions): +test tc2consistent_P6C [main=Test2ConsistentP6C]: assert P6C in (union Walker, { Test2ConsistentP6C }); diff --git a/formal/walker/PTst/Scenario3.p b/formal/walker/PTst/Scenario3.p new file mode 100644 index 000000000..5ebe9f83a --- /dev/null +++ b/formal/walker/PTst/Scenario3.p @@ -0,0 +1,115 @@ +/* Scenario 3 — artifact swap + hit rebind (MODEL_SPEC 9 case 3). + World: upstream sits at e2 throughout (preMutate) and never moves. + Sync 1 seals artifact A = rows(e2) under V_A = 2. Sync 2 is the + premise sync: the stop strands the carrier and MEnv swaps the + previous artifact to sibling B = rows(e1) under V_B = 1 (equal + compat; truthful validators — V_B does not validate against e2, and + rows(B) != rows(up) = rows(A)). Expected verdicts: + - tc3a_P1 (shipped: hitValidatorBinding ON — the residual hole): + RED. Attempt 2's re-consult overwrites the hit map with V_B + (lookup-time recording, last-write-wins); revalidation fails; + verdict fetch-fresh. The carrier then passes the binding check + (hit V_B == base B's manifest V_B) and installs rows(B) while + publishing its annotation's V_A. Carrier-last schedules seal + rows(B) under entry V_A -> P1-ATTEST-SEAL; carrier-first or + interleaved schedules leave B's id-1 debris under the fresh round + -> P1-CONTENT. Schedules where the carrier drains BEFORE the + re-consult hit the binding gate honestly (hit still V_A != base + V_B) -> loud cold, green: both faces of the same toggle. + - tc3a_P2: GREEN in every cell — attempt 1's validation match + qualifies the scope as consulted this sync, and copied rows carry + hops 1 (corrected expectation; spec v2 wrongly claimed a P2 red). + - tc3b_P1 (pre-CO-6b-004: hitValidatorBinding OFF, 1-page planning + that pops at the stop checkpoint): RED on a weaker premise — no + re-consult exists, the hit map keeps V_A, and NO binding check + runs: the carrier copies swapped base B and publishes V_A -> + P1-ATTEST-SEAL. + - tc3bBindingOn_All (same premise, binding ON — the CO-6b-004 + kill): GREEN — the binding gate compares hit V_A to base V_B, + fails loud-cold, and no wrong data lands (the scope seals empty + in the premise schedules). + The annotationBinding fix runs (3A fix + empty-validator coverage + cell) are de-scoped from the build with the toggle itself (v11). */ + +fun noBindingToggles(): tToggles { + return (warmGate = true, hitValidatorBinding = false, scopeLocks = true, oncePerScope = true, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = false); +} + +machine Test3A { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 3; + c.interrupt = 1; + c.preMutate = true; + c.swapBase = true; + new MEnv(c); + } + } +} + +machine Test3B { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 3; + c.cell = 31; + c.interrupt = 1; + c.preMutate = true; + c.swapBase = true; + c.toggles = noBindingToggles(); + new MEnv(c); + } + } +} + +machine Test3BBindOn { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 3; + c.cell = 31; + c.interrupt = 1; + c.preMutate = true; + c.swapBase = true; + new MEnv(c); + } + } +} + +/* v11 — the case-3 re-run under V-ATOMIC (MODEL_SPEC 9.6): the + subsumption witness for the annotationBinding de-scope. Same stop + + base-swap premise as 3A, but replay is consult-inline with the + atomic unit: no carrier and no annotation exist to trust; the marker + lives in the CURRENT sync's artifact (untouched by the swap); + restored hits are inert. Either the unit committed before the stop + (attempt 2 marker-suppresses — the seal is the unit's coherent + contents) or nothing did (attempt 2 re-consults the ACTUALLY current + base: swapped B's V1 fails validation against upstream e2 → + fetch-fresh). Expected GREEN across P1/P2/P3'. */ +machine Test3Atomic { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 3; + c.variant = VAR_ATOMIC; + c.interrupt = 1; + c.preMutate = true; + c.swapBase = true; + new MEnv(c); + } + } +} + +// Expected RED (the residual hole, then the weaker pre-fix premise): +test tc3a_P1 [main=Test3A]: assert P1 in (union Walker, { Test3A }); +test tc3b_P1 [main=Test3B]: assert P1 in (union Walker, { Test3B }); + +// Expected GREEN: +test tc3a_P2 [main=Test3A]: assert P2 in (union Walker, { Test3A }); +test tc3bBindingOn_All [main=Test3BBindOn]: assert P1, P2, P3prime in (union Walker, { Test3BBindOn }); +test tc3atomic_All [main=Test3Atomic]: assert P1, P2, P3prime in (union Walker, { Test3Atomic }); diff --git a/formal/walker/PTst/Scenario4.p b/formal/walker/PTst/Scenario4.p new file mode 100644 index 000000000..bbb9fd295 --- /dev/null +++ b/formal/walker/PTst/Scenario4.p @@ -0,0 +1,83 @@ +/* Scenario 4 — duplicate replay carriers (MODEL_SPEC 9 case 4). + Two carriers with byte-distinct page tokens (distinct aids) encoding + the same (scope, verdict); no interruption, no mutation; 2 syncs. + Expected verdicts: + - tc4shipped_All (oncePerScope + scopeLocks ON): GREEN — the second + carrier's copy is deduped under the lock (grant carries the + replayed status; the mark commits at release); its B5-legal + copy-skipped round folds as a no-op re-publish. + - tc4noOnce_P1 (oncePerScope OFF, locks ON): RED — P1-LEGALITY, + both copies commit (the lock serializes but does not dedup). + - tc4noLocks_P1 (oncePerScope ON, locks OFF): RED — P1-LEGALITY via + the check-then-mark TOCTOU: both carriers read the replayed set + before either transition commits the mark. + - tc4atomic_All (V-ATOMIC re-run, v11 scope): GREEN — carriers do + not exist under the variant (replay is inline at the consult); + the duplicate-carrier premise is structurally unreachable. */ + +fun noOnceToggles(): tToggles { + return (warmGate = true, hitValidatorBinding = true, scopeLocks = true, oncePerScope = false, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = false); +} + +fun noLocksToggles(): tToggles { + return (warmGate = true, hitValidatorBinding = true, scopeLocks = false, oncePerScope = true, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = false); +} + +machine Test4Shipped { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 4; + c.cell = 4; + new MEnv(c); + } + } +} + +machine Test4NoOnce { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 4; + c.cell = 4; + c.toggles = noOnceToggles(); + new MEnv(c); + } + } +} + +machine Test4NoLocks { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 4; + c.cell = 4; + c.toggles = noLocksToggles(); + new MEnv(c); + } + } +} + +machine Test4Atomic { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 4; + c.variant = VAR_ATOMIC; + c.cell = 4; + new MEnv(c); + } + } +} + +// Expected RED (mitigation kill runs): +test tc4noOnce_P1 [main=Test4NoOnce]: assert P1 in (union Walker, { Test4NoOnce }); +test tc4noLocks_P1 [main=Test4NoLocks]: assert P1 in (union Walker, { Test4NoLocks }); + +// Expected GREEN: +test tc4shipped_All [main=Test4Shipped]: assert P1, P2, P3prime in (union Walker, { Test4Shipped }); +test tc4atomic_All [main=Test4Atomic]: assert P1, P2, P3prime in (union Walker, { Test4Atomic }); diff --git a/formal/walker/PTst/Scenario5.p b/formal/walker/PTst/Scenario5.p new file mode 100644 index 000000000..4f197884f --- /dev/null +++ b/formal/walker/PTst/Scenario5.p @@ -0,0 +1,131 @@ +/* Scenario 5 — warm-drift (MODEL_SPEC 9 case 5): the warmGate kill and + both produce-side block triggers. World: upstream never moves (drift + is config-side). Sync 1 seeds artifact A = rows(e1) under V1 with + compat record K1 (baseConfig = 1). Sync 2 is the premise sync: + attempt 1 (warm, K1) consults, records hit {S: V1}, spawns carrier C + (cell-31 planning shape: consult+spawn+pop) and the stop strands C; + MEnv applies the scripted drift input to attempt 2 ONLY in premise + histories (checkpoint holds a stranded carrier), so non-premise + schedules run undrifted and green. Expected verdicts: + - tc5a_P1 (cell 51, warmGate OFF — the kill): RED. Attempt 2 + computes K2; install: G7 mismatch -> COLD, trigger 1 (B4) marks + produce-blocked. With the gate off, C passes the hit check + (restored {S: V1}) and binding (base unchanged, V1) and copies + K1-tagged rows into the K2 attempt -> P1-CONFIG (clause c). + - tc5a_Gate_All (cell 51, shipped toggles — warmGate ON): GREEN. + C's warm-gate check fails LOUD (eAnnLoudCold, chain cold, no + ops); the artifact seals blocked with partition[S] empty. The + attempt-failure/abandonLadder ladder is P4's tranche; here loud + cold ends the chain and the sync seals (scenario-3 precedent). + - tc5b_Dropout_All (cell 52, shipped toggles, G6 withdrawn in + attempt 2): GREEN, and the green IS the required design finding: + trigger 2 blocks the artifact at install; C's replay-annotated + page arrives in the handling-less attempt and is SILENTLY + IGNORED (B1) — no failure, no rows; the sync seals green with + partition[S] EMPTY and the artifact blocked. P1/P2 are blind + here (no rows, no illegal round); SealExpect's scripted + wantBlocked + wantScopeEmpty expectation is the dropout's only + executable oracle (MODEL_SPEC 9.5b). + - tc5b_CrashWindow (cell 52, interrupt 3 = stop attempt 1, crash + attempt 2): RED on SealExpect — the crash-window finding. + Trigger 2's block lives ONLY in attempt 2's volatile flag until + a checkpoint carries it; a crash landing before that first + checkpoint kills the flag with the attempt. Attempt 3 has + handling back (withdrawal is attempt-2-exact), re-detects + nothing (no compat mismatch), runs warm, and seals UNBLOCKED — + the expectation's wantBlocked assert fires. Schedules where the + crash lands after a checkpoint carrying the flag seal blocked + and stay green: the red is exactly the window. + - tc5c_C1Probe (cell 53, shipped toggles, plain stop): RED on the + C1Probe reachability monitor — the CO-6b-002 conformance answer. + One action, replay annotation MID-CHAIN: page 0 consults (hit + recorded at lookup), page 1 replays. The stop lands between the + pages; the checkpoint holds the mid-chain cursor + the hit map; + the resumed page 1 performs NO fresh consult and its hit check + passes on the RESTORED map. The counterexample trace is the + witness (finding, not a bug); confirm against the real + implementation via the chaos bridge (deliverable 6). */ + +machine Test5aGateOff { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 5; + c.cell = 51; + c.interrupt = 1; + c.baseConfig = 1; + c.driftCompat = true; + c.toggles = (warmGate = false, hitValidatorBinding = true, scopeLocks = true, oncePerScope = true, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = false); + new MEnv(c); + } + } +} + +machine Test5aGateOn { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 5; + c.cell = 51; + c.interrupt = 1; + c.baseConfig = 1; + c.driftCompat = true; + new MEnv(c); + } + } +} + +machine Test5bDropout { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 5; + c.cell = 52; + c.interrupt = 1; + c.baseConfig = 1; + c.withdrawG6 = true; + new MEnv(c); + } + } +} + +machine Test5bCrash { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 5; + c.cell = 52; + c.interrupt = 3; + c.baseConfig = 1; + c.withdrawG6 = true; + new MEnv(c); + } + } +} + +machine Test5cC1 { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 5; + c.cell = 53; + c.interrupt = 1; + new MEnv(c); + } + } +} + +// Expected RED (the warmGate kill, the crash-window finding, then the +// C1 reachability witness): +test tc5a_P1 [main=Test5aGateOff]: assert P1 in (union Walker, { Test5aGateOff }); +test tc5b_CrashWindow [main=Test5bCrash]: assert SealExpect in (union Walker, { Test5bCrash }); +test tc5c_C1Probe [main=Test5cC1]: assert C1Probe, P1, P2 in (union Walker, { Test5cC1 }); + +// Expected GREEN: +test tc5a_Gate_All [main=Test5aGateOn]: assert P1, P2, SealExpect in (union Walker, { Test5aGateOn }); +test tc5b_Dropout_All [main=Test5bDropout]: assert P1, P2, SealExpect in (union Walker, { Test5bDropout }); diff --git a/formal/walker/PTst/Scenario6.p b/formal/walker/PTst/Scenario6.p new file mode 100644 index 000000000..aaf6fecda --- /dev/null +++ b/formal/walker/PTst/Scenario6.p @@ -0,0 +1,201 @@ +/* Scenario 6 — atomic-unit design variant, fetch-fresh flavor + (MODEL_SPEC 9 case 6). The bake-off pair plus the V-ATOMIC re-runs + of the scenario-1 premise family. Expected verdicts: + - tc6naive_P1 (V-NAIVE: marker as a separate op outside any unit, + crash script): P1-CONTENT red — a crash between eCopyScope and the + marker leaves unmarked debris; the resumed attempt re-consults, + revalidation fails, and the fresh round unions over the debris. + - tc6atomic_All (V-ATOMIC, same crash script): GREEN — the unit + {clear, copy, marker, publish} holds one queue position; every + crash placement leaves either nothing or the complete unit, and + the marker suppresses re-derivation on resume. + - tc6atomicStop_All (V-ATOMIC, stop-stranding script of 1a/1b): + GREEN — replay executes inline on the consulting page, so the + stranded-carrier premise is structurally unreachable. + Both variants run with the shipped mitigation toggles ON; the + variant is a commit-structure change, not a toggle (MODEL_SPEC 9.6). */ + +machine Test6Naive { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_NAIVE; + c.cell = 3; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test6Atomic { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_ATOMIC; + c.cell = 3; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test6AtomicStop { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_ATOMIC; + c.interrupt = 1; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +/* v10 addendum — overlay flavor. 6-overlay runs with oncePerScope AND + scopeLocks OFF (the structural claim 1d could not make); the marker + inside the unit is the dedup. 6-overlay-naive runs shipped toggles; + its defect is the unit boundary, which no toggle repairs. + mutateBetweenAttempts stays ON in the crash cells (the pre-refactor + env mutated unconditionally on crash; the green claims were made + under that broader drift and are preserved as-is). */ + +fun overlayToggles(): tToggles { + return (warmGate = true, hitValidatorBinding = true, scopeLocks = false, oncePerScope = false, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = false); +} + +machine Test6OverlayCrash { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_OVERLAY_UNIT; + c.cell = 3; + c.interrupt = 2; + c.toggles = overlayToggles(); + c.mutateBetweenAttempts = true; + c.mutateBetweenSyncs = true; + new MEnv(c); + } + } +} + +machine Test6OverlayStop { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_OVERLAY_UNIT; + c.interrupt = 1; + c.toggles = overlayToggles(); + c.mutateBetweenSyncs = true; + new MEnv(c); + } + } +} + +/* MS-CO-001 (parallel-review F6) — the o-iv-removal mutant: the + 6-overlay STOP config with the consult-reset removed (o4Mutant). + In sub-case (b)'s schedule the resume honors the restored mid-chain + cursor with an EMPTY collect buffer, collects only the final overlay + page, and commits a unit missing the first page's ops → partition + diverges from the self-grounding fold's rows(e2). Expected RED + (P1-CONTENT); kills the one load-bearing line the overlay flavor + adds beyond V-ATOMIC. */ +machine Test6OverlayMutO4 { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_OVERLAY_UNIT; + c.interrupt = 1; + c.toggles = overlayToggles(); + c.mutateBetweenSyncs = true; + c.o4Mutant = true; + new MEnv(c); + } + } +} + +machine Test6OverlayNaive { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_OVERLAY_NAIVE; + c.cell = 3; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.mutateBetweenSyncs = true; + new MEnv(c); + } + } +} + +/* v11 (round-7 F2) — the third placement gets its own cell. Same crash + premise as 6-overlay-naive; the placement differs: NO unit — clear+ + copy per-page at the replay boundary, marker+publish LAST as two + separate trailing ops. Expected RED via w2 (crash between marker and + publish: marked, entry-less, content-complete scope suppressed on + resume; non-empty partition vs EMPTY fold). w1 (crash before the + marker) must NOT alarm: the re-verdict's clear wipes the debris and + the cross-attempt double copy is legal under the complete-rounds + replacement-counting pin — the pre-pin monitor would have raised + P1-LEGALITY on this converging history. */ +machine Test6OverlayLast { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_OVERLAY_LAST; + c.cell = 3; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.mutateBetweenSyncs = true; + new MEnv(c); + } + } +} + +machine Test6OverlayNaiveVerify { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 6; + c.variant = VAR_OVERLAY_NAIVE; + c.cell = 3; + c.interrupt = 2; + c.mutateBetweenAttempts = true; + c.mutateBetweenSyncs = true; + c.nSyncs = 3; + c.verificationOnlyIfInterrupted = true; + new MEnv(c); + } + } +} + +// Expected RED: +test tc6naive_P1 [main=Test6Naive]: assert P1 in (union Walker, { Test6Naive }); +test tc6overlayNaive_P1 [main=Test6OverlayNaive]: assert P1 in (union Walker, { Test6OverlayNaive }); +test tc6overlayNaive_P2 [main=Test6OverlayNaiveVerify]: assert P2 in (union Walker, { Test6OverlayNaiveVerify }); +test tc6overlayLast_P1 [main=Test6OverlayLast]: assert P1 in (union Walker, { Test6OverlayLast }); +test tc6overlayMutO4_P1 [main=Test6OverlayMutO4]: assert P1 in (union Walker, { Test6OverlayMutO4 }); + +// Expected GREEN (the structural claim): +test tc6atomic_All [main=Test6Atomic]: assert P1, P2, P3prime in (union Walker, { Test6Atomic }); +test tc6atomicStop_All [main=Test6AtomicStop]: assert P1, P2, P3prime in (union Walker, { Test6AtomicStop }); +test tc6overlay_All [main=Test6OverlayCrash]: assert P1, P2, P3prime in (union Walker, { Test6OverlayCrash }); +test tc6overlayStop_All [main=Test6OverlayStop]: assert P1, P2, P3prime in (union Walker, { Test6OverlayStop }); diff --git a/formal/walker/PTst/Scenario7.p b/formal/walker/PTst/Scenario7.p new file mode 100644 index 000000000..03ee64955 --- /dev/null +++ b/formal/walker/PTst/Scenario7.p @@ -0,0 +1,144 @@ +/* Scenario 7 — session elision under replay (MODEL_SPEC 9 case 7, + signoff addendum). Pure two-sync scripts, no interruption machinery. + Kinds in sequential phases: W (scope 0) writes session key K as a + side effect of its FRESH enumeration; R (scope 1) derives its rows' + ghost stamps from reading K. The shipped design has no coupling + between sessions and the source cache, and R's connector violates + no pinned obligation in any cell — the missing contract clause IS + the design finding. Expected verdicts: + - tc7a_P6R (write elision): RED — W warm-replays, its session write + is structurally elided, R (policy: always fresh) reads MISS and + stamps 0; counterfactual v1. + - tc7a_P1P2 GREEN — required finding: every row individually + well-formed, every scope consulted; the corruption is invisible + to content/attestation/staleness checks. + - tc7b_P6R (stale-read replay, the dual): RED — W's upstream moves + between syncs (W fresh, writes v2) while R's scope is unchanged + (R warm; copied rows carry stamp v1); counterfactual v2. No + elided write anywhere — this cell kills write-only bans. + - tc7c_All (both-warm control): GREEN — carried stamps v1 equal the + counterfactual v1; required so P6-R does not overfit to "replay + near sessions alarms". + Fix runs (produce-side taint; the full two-sync script re-executes + with the toggle ON — sync N's artifact differs from the red run's): + - tc7aTaintW_P6R: GREEN — sync N taints W (write during a capable + phase); sync N+1 consults W MISS, W re-runs fresh, K present. + - tc7bTaintW_P6R: RED — REQUIRED residual: R's hazard is a READ; + the write-only rule is half a fix. + - tc7aTaintAll_P6R, tc7bTaintAll_P6R: GREEN — R's read taints R's + kind too; replay is forfeited exactly where sessions are used + (the toggle's honest price, recorded not hidden). */ + +fun taintWritesToggles(): tToggles { + return (warmGate = true, hitValidatorBinding = true, scopeLocks = true, oncePerScope = true, annotationBinding = false, abandonLadder = false, sessionTaintWrites = true, sessionTaintAll = false); +} + +fun taintAllToggles(): tToggles { + return (warmGate = true, hitValidatorBinding = true, scopeLocks = true, oncePerScope = true, annotationBinding = false, abandonLadder = false, sessionTaintWrites = false, sessionTaintAll = true); +} + +machine Test7a { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 7; + c.cell = 7; + c.readerAlwaysFresh = true; + new MEnv(c); + } + } +} + +machine Test7b { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 7; + c.cell = 7; + c.mutateBetweenSyncs = true; + new MEnv(c); + } + } +} + +machine Test7c { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 7; + c.cell = 7; + new MEnv(c); + } + } +} + +machine Test7aTaintW { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 7; + c.cell = 7; + c.readerAlwaysFresh = true; + c.toggles = taintWritesToggles(); + new MEnv(c); + } + } +} + +machine Test7bTaintW { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 7; + c.cell = 7; + c.mutateBetweenSyncs = true; + c.toggles = taintWritesToggles(); + new MEnv(c); + } + } +} + +machine Test7aTaintAll { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 7; + c.cell = 7; + c.readerAlwaysFresh = true; + c.toggles = taintAllToggles(); + new MEnv(c); + } + } +} + +machine Test7bTaintAll { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 7; + c.cell = 7; + c.mutateBetweenSyncs = true; + c.toggles = taintAllToggles(); + new MEnv(c); + } + } +} + +// Expected RED (design findings, then the required fix residual): +test tc7a_P6R [main=Test7a]: assert P6R in (union Walker, { Test7a }); +test tc7b_P6R [main=Test7b]: assert P6R in (union Walker, { Test7b }); +test tc7bTaintW_P6R [main=Test7bTaintW]: assert P6R in (union Walker, { Test7bTaintW }); + +// Expected GREEN: +test tc7a_P1P2 [main=Test7a]: assert P1, P2 in (union Walker, { Test7a }); +test tc7c_All [main=Test7c]: assert P1, P2, P3prime, P6A, P6R in (union Walker, { Test7c }); +test tc7aTaintW_P6R [main=Test7aTaintW]: assert P6R in (union Walker, { Test7aTaintW }); +test tc7aTaintAll_P6R [main=Test7aTaintAll]: assert P6R in (union Walker, { Test7aTaintAll }); +test tc7bTaintAll_P6R [main=Test7bTaintAll]: assert P6R in (union Walker, { Test7bTaintAll }); diff --git a/formal/walker/PTst/Scenario8.p b/formal/walker/PTst/Scenario8.p new file mode 100644 index 000000000..611ffb818 --- /dev/null +++ b/formal/walker/PTst/Scenario8.p @@ -0,0 +1,118 @@ +/* Scenario 8 — external principals (SyncExternalResources x + crash-resume; the deleteStaleExternalPrincipals contract). One + sync, one external-phase action (cell 8): page 0 LISTs the source's + current answer and commits the reconciliation op; page 1 COPYs the + answer's principals. The external answer is the truthful epoch + table (e1 = {0,1}; e2 = {0} — the between-attempt shrink drops + principal 1). Committed copies are durable across crashes — the + debris premise — and a resumed phase restarts from its root token. + Expected verdicts: + - tc8green_P8 (no interruption, no mutation): GREEN — cold baseline. + - tc8crash_P8 (hard crash in attempt 1, shrink between attempts, + capable engine): GREEN — every crash placement heals: the resumed + attempt re-lists the current answer and reconciliation deletes + the dead attempt's stale copies before the fresh writes. Includes + the completed-then-crash schedules where attempt 2 seals attempt + 1's answer without re-running the phase — deliberately green + (sync-scoped freshness; the P8 seal clause compares against the + last-RUN list, not truth-at-seal). + - tc8stop_P8 (graceful stop + shrink, capable engine): GREEN — the + restart-from-root reset re-lists; no mid-phase cursor can copy a + fresh answer over a stale reconciliation. + - tc8reconOff_P8 (crash + shrink, NON-DELETING ENGINE): RED on + P8-EXT-STALE — the warn-and-continue degrade ships the dead + attempt's principal 1 in the sealed artifact (the SQLite + degradation pinned by + SQLiteExternalPrincipalResumeDegradesWithoutFailure). + - tc8staleList_P8 (crash + shrink, resume consumes the dead + attempt's answer): RED on P8-EXT-CURRENT — the recency mutant the + ResumeUsesCurrentExternalAnswer chaos pin forbids. */ + +machine Test8Green { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 8; + c.nSyncs = 1; + new MEnv(c); + } + } +} + +machine Test8Crash { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 8; + c.interrupt = 2; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test8Stop { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 8; + c.interrupt = 1; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + new MEnv(c); + } + } +} + +machine Test8ReconOff { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 8; + c.interrupt = 2; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + c.extRecon = false; + new MEnv(c); + } + } +} + +machine Test8StaleList { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 8; + c.interrupt = 2; + c.interruptSync = 1; + c.nSyncs = 1; + c.mutateBetweenAttempts = true; + c.extStaleList = true; + new MEnv(c); + } + } +} + +// Expected GREEN (the shipped capable-engine path heals every +// interruption placement): +test tc8green_P8 [main=Test8Green]: assert P8 in (union Walker, { Test8Green }); +test tc8crash_P8 [main=Test8Crash]: assert P8 in (union Walker, { Test8Crash }); +test tc8stop_P8 [main=Test8Stop]: assert P8 in (union Walker, { Test8Stop }); + +// Expected RED (the degrade path's debris; the recency mutant): +test tc8reconOff_P8 [main=Test8ReconOff]: assert P8 in (union Walker, { Test8ReconOff }); +test tc8staleList_P8 [main=Test8StaleList]: assert P8 in (union Walker, { Test8StaleList }); diff --git a/formal/walker/PTst/ScenarioP4.p b/formal/walker/PTst/ScenarioP4.p new file mode 100644 index 000000000..f690dc08c --- /dev/null +++ b/formal/walker/PTst/ScenarioP4.p @@ -0,0 +1,106 @@ +/* P4 tranche — progress (MODEL_SPEC 7 P4, 4 failure semantics). + Attempt-level loud failure is ON in these cells only + (cfg.loudColdFailsAttempt — decision 10's deviation closes here): + a cold verdict fails the ATTEMPT; the offending cursor is + checkpointed, so the failure recurs deterministically on resume. + + Stuck/ladder premise = the 5a drift script (cell 51, warmGate ON): + sync 2 attempt 1 strands carrier C; drift lands K2 and PERSISTS + (env latch); every resume dispatches C cold and fails loud at the + warm gate from byte-identical restored state. + - tcP4stuck_P4 (abandonLadder OFF): RED on P4-STUCK — attempts 2 + and 3 fail consecutively from identical restored checkpoint + state {[C@0], hits {S:V1}} at the same step (warm gate, cursor + 0) — CO-6b-004's deterministic re-failure / stuck-resume + finding. Budget exhaustion is the recorded outcome shape. + - tcP4ladder_All (abandonLadder ON, k = 2, 3 syncs): GREEN incl. + the P4Live liveness monitor — after 2 identical failures the env + abandons sync 2 UNSEALED; sync 3 starts against the last sealed + artifact (sync 1's), runs COLD (persisted K2 vs the K1 compat + record — the 6c ladder's "next sync runs cold"), fetches fresh, + and SEALS: the chain eventually seals, no wrong rows (P1's + config clause holds: K2 rows under a K2 seal). + + Leaked-lock premise = CO-6b-007 (cell 31, no interruption): the + carrier's replay page suffers ONE injected destination-write + failure after acquiring the scope lock; the worker retries + IN-ATTEMPT, re-entering the page sequence (syncOneAction's retry + loop). + - tcP4leak_P1 (release-on-error edge REMOVED — the mutation + check): RED as a checker DEADLOCK — the retry re-requests the + scope lock it still holds and waits forever on its own leak; the + attempt never seals and the env never unblocks. + - tcP4release_All (edge present, shipped): GREEN — the retry + re-acquires cleanly, the page completes, the sync seals. */ + +machine TestP4Stuck { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 51; + c.interrupt = 1; + c.baseConfig = 1; + c.driftCompat = true; + c.loudColdFailsAttempt = true; + new MEnv(c); + } + } +} + +machine TestP4Ladder { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 51; + c.interrupt = 1; + c.baseConfig = 1; + c.driftCompat = true; + c.loudColdFailsAttempt = true; + c.nSyncs = 3; + c.toggles = (warmGate = true, hitValidatorBinding = true, scopeLocks = true, oncePerScope = true, annotationBinding = false, abandonLadder = true, sessionTaintWrites = false, sessionTaintAll = false); + new MEnv(c); + } + } +} + +machine TestP4Leak { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 31; + c.warmPageFails = true; + c.lockReleaseOnError = false; + new MEnv(c); + } + } +} + +machine TestP4Release { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 31; + c.warmPageFails = true; + new MEnv(c); + } + } +} + +// Expected RED (stuck-resume detection; then the leaked-lock DEADLOCK — +// the checker's deadlock report, no monitor involved): +test tcP4stuck_P4 [main=TestP4Stuck]: assert P4Stuck in (union Walker, { TestP4Stuck }); +test tcP4leak_P1 [main=TestP4Leak]: assert P1 in (union Walker, { TestP4Leak }); + +// Expected GREEN (P4Stuck is deliberately NOT asserted in the ladder +// cell: the ladder abandons exactly when detection fires — k = 2 IS +// the deterministic re-failure; the cell's claim is the recovery): +test tcP4ladder_All [main=TestP4Ladder]: assert P4Live, P1, P2 in (union Walker, { TestP4Ladder }); +test tcP4release_All [main=TestP4Release]: assert P1, P2 in (union Walker, { TestP4Release }); diff --git a/formal/walker/tools/sweep.sh b/formal/walker/tools/sweep.sh new file mode 100755 index 000000000..802c8a524 --- /dev/null +++ b/formal/walker/tools/sweep.sh @@ -0,0 +1,92 @@ +#!/usr/bin/env bash +# Full-cell regression sweep. Verdicts are audited by counterexample +# trace-file presence (NOT the "Found N bugs" tail — see the NOTE in +# CALIBRATION.md: the strategy portfolio's last block can report 0 +# bugs after an earlier block found one). +# +# Usage: tools/sweep.sh [schedules] (run from formal/walker) +set -u +S="${1:-10000}" +OUT="PCheckerOutput/sweep" +SUMMARY="$OUT/summary.txt" +mkdir -p "$OUT" +: > "$SUMMARY" + +# cell:expected (RED = counterexample expected, GREEN = none) +CELLS=" +tc1a1b_P1:RED +tc1a1b_P2:RED +tc1a1b_P3:RED +tc1bii_P1:RED +tc1c_P1:RED +tc1c_P1_probe:RED +tc1c_P2:RED +tc1c_P2_honest:GREEN +tcGreen_All:GREEN +tc2stop_P6A:RED +tc2crash_P6A:RED +tc2green_P6A:GREEN +tc2crash_P6C:RED +tc2clear_P6C:RED +tc2consistent_P6C:GREEN +tc3a_P1:RED +tc3a_P2:GREEN +tc3b_P1:RED +tc3bBindingOn_All:GREEN +tc3atomic_All:GREEN +tc4shipped_All:GREEN +tc4atomic_All:GREEN +tc4noOnce_P1:RED +tc4noLocks_P1:RED +tc5a_P1:RED +tc5a_Gate_All:GREEN +tc5b_Dropout_All:GREEN +tc5b_CrashWindow:RED +tc5c_C1Probe:RED +tc6naive_P1:RED +tc6atomic_All:GREEN +tc6atomicStop_All:GREEN +tc6overlayNaive_P1:RED +tc6overlayNaive_P2:RED +tc6overlayLast_P1:RED +tc6overlayMutO4_P1:RED +tc6overlay_All:GREEN +tc6overlayStop_All:GREEN +tc7a_P6R:RED +tc7a_P1P2:GREEN +tc7b_P6R:RED +tc7c_All:GREEN +tc7aTaintW_P6R:GREEN +tc7bTaintW_P6R:RED +tc7aTaintAll_P6R:GREEN +tc7bTaintAll_P6R:GREEN +tcP4stuck_P4:RED +tcP4ladder_All:GREEN +tcP4leak_P1:RED +tcP4release_All:GREEN +tc8green_P8:GREEN +tc8crash_P8:GREEN +tc8stop_P8:GREEN +tc8reconOff_P8:RED +tc8staleList_P8:RED +" + +mismatches=0 +total=0 +for entry in $CELLS; do + cell="${entry%%:*}" + expected="${entry##*:}" + total=$((total + 1)) + rm -rf "$OUT/$cell" + p check -tc "$cell" -s "$S" -o "$OUT/$cell" > "$OUT/$cell.log" 2>&1 + ce=$(ls "$OUT/$cell"/BugFinding/walker_[0-9]*_[0-9]*.txt 2>/dev/null | head -1) + if [ -n "$ce" ]; then observed="RED"; else observed="GREEN"; fi + if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi + detail="" + if [ "$observed" = "RED" ]; then + detail=" [$(rg -o "(P[0-9][0-9A-Z'-]*[A-Z]|SEAL-EXPECT|C1-PROBE|P4-STUCK|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" + fi + line="$cell expected=$expected observed=$observed $mark$detail" + echo "$line" | tee -a "$SUMMARY" +done +echo "SWEEP-DONE cells=$total mismatches=$mismatches" | tee -a "$SUMMARY" diff --git a/formal/walker/traces/freeze-sweep-v11-summary.txt b/formal/walker/traces/freeze-sweep-v11-summary.txt new file mode 100644 index 000000000..987f9056d --- /dev/null +++ b/formal/walker/traces/freeze-sweep-v11-summary.txt @@ -0,0 +1,47 @@ +tc1a1b_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1a1b_P2 expected=RED observed=RED ok [P2-STALENESS] +tc1a1b_P3 expected=RED observed=RED ok [P3'-COHERENCE] +tc1bii_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1c_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1c_P1_probe expected=RED observed=RED ok [P1-CONTENT] +tc1c_P2 expected=RED observed=RED ok [P2-STALENESS] +tc1c_P2_honest expected=GREEN observed=GREEN ok +tcGreen_All expected=GREEN observed=GREEN ok +tc2stop_P6A expected=RED observed=RED ok [P6-A,P6A] +tc2crash_P6A expected=RED observed=RED ok [P6-A,P6A] +tc2green_P6A expected=GREEN observed=GREEN ok +tc3a_P1 expected=RED observed=RED ok [P1-CONTENT] +tc3a_P2 expected=GREEN observed=GREEN ok +tc3b_P1 expected=RED observed=RED ok [P1-ATTEST-SEAL] +tc3bBindingOn_All expected=GREEN observed=GREEN ok +tc3atomic_All expected=GREEN observed=GREEN ok +tc4shipped_All expected=GREEN observed=GREEN ok +tc4atomic_All expected=GREEN observed=GREEN ok +tc4noOnce_P1 expected=RED observed=RED ok [P1-LEGALITY] +tc4noLocks_P1 expected=RED observed=RED ok [P1-LEGALITY] +tc5a_P1 expected=RED observed=RED ok [P1-CONFIG] +tc5a_Gate_All expected=GREEN observed=GREEN ok +tc5b_Dropout_All expected=GREEN observed=GREEN ok +tc5b_CrashWindow expected=RED observed=RED ok [SEAL-EXPECT] +tc5c_C1Probe expected=RED observed=RED ok [C1-PROBE] +tc6naive_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6atomic_All expected=GREEN observed=GREEN ok +tc6atomicStop_All expected=GREEN observed=GREEN ok +tc6overlayNaive_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlayNaive_P2 expected=RED observed=RED ok [P2-STALENESS] +tc6overlayLast_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlay_All expected=GREEN observed=GREEN ok +tc6overlayStop_All expected=GREEN observed=GREEN ok +tc7a_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7a_P1P2 expected=GREEN observed=GREEN ok +tc7b_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7c_All expected=GREEN observed=GREEN ok +tc7aTaintW_P6R expected=GREEN observed=GREEN ok +tc7bTaintW_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7aTaintAll_P6R expected=GREEN observed=GREEN ok +tc7bTaintAll_P6R expected=GREEN observed=GREEN ok +tcP4stuck_P4 expected=RED observed=RED ok [P4-STUCK,P4S] +tcP4ladder_All expected=GREEN observed=GREEN ok +tcP4leak_P1 expected=RED observed=RED ok [Deadlock detected,P4L] +tcP4release_All expected=GREEN observed=GREEN ok +SWEEP-DONE cells=46 mismatches=0 diff --git a/formal/walker/traces/msco001-sweep-summary.txt b/formal/walker/traces/msco001-sweep-summary.txt new file mode 100644 index 000000000..7f27e8e12 --- /dev/null +++ b/formal/walker/traces/msco001-sweep-summary.txt @@ -0,0 +1,48 @@ +tc1a1b_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1a1b_P2 expected=RED observed=RED ok [P2-STALENESS] +tc1a1b_P3 expected=RED observed=RED ok [P3'-COHERENCE] +tc1bii_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1c_P1 expected=RED observed=RED ok [P1-CONTENT] +tc1c_P1_probe expected=RED observed=RED ok [P1-CONTENT] +tc1c_P2 expected=RED observed=RED ok [P2-STALENESS] +tc1c_P2_honest expected=GREEN observed=GREEN ok +tcGreen_All expected=GREEN observed=GREEN ok +tc2stop_P6A expected=RED observed=RED ok [P6-A,P6A] +tc2crash_P6A expected=RED observed=RED ok [P6-A,P6A] +tc2green_P6A expected=GREEN observed=GREEN ok +tc3a_P1 expected=RED observed=RED ok [P1-CONTENT] +tc3a_P2 expected=GREEN observed=GREEN ok +tc3b_P1 expected=RED observed=RED ok [P1-ATTEST-SEAL] +tc3bBindingOn_All expected=GREEN observed=GREEN ok +tc3atomic_All expected=GREEN observed=GREEN ok +tc4shipped_All expected=GREEN observed=GREEN ok +tc4atomic_All expected=GREEN observed=GREEN ok +tc4noOnce_P1 expected=RED observed=RED ok [P1-LEGALITY] +tc4noLocks_P1 expected=RED observed=RED ok [P1-LEGALITY] +tc5a_P1 expected=RED observed=RED ok [P1-CONFIG] +tc5a_Gate_All expected=GREEN observed=GREEN ok +tc5b_Dropout_All expected=GREEN observed=GREEN ok +tc5b_CrashWindow expected=RED observed=RED ok [SEAL-EXPECT] +tc5c_C1Probe expected=RED observed=RED ok [C1-PROBE] +tc6naive_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6atomic_All expected=GREEN observed=GREEN ok +tc6atomicStop_All expected=GREEN observed=GREEN ok +tc6overlayNaive_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlayNaive_P2 expected=RED observed=RED ok [P2-STALENESS] +tc6overlayLast_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlayMutO4_P1 expected=RED observed=RED ok [P1-CONTENT] +tc6overlay_All expected=GREEN observed=GREEN ok +tc6overlayStop_All expected=GREEN observed=GREEN ok +tc7a_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7a_P1P2 expected=GREEN observed=GREEN ok +tc7b_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7c_All expected=GREEN observed=GREEN ok +tc7aTaintW_P6R expected=GREEN observed=GREEN ok +tc7bTaintW_P6R expected=RED observed=RED ok [P6-R,P6R] +tc7aTaintAll_P6R expected=GREEN observed=GREEN ok +tc7bTaintAll_P6R expected=GREEN observed=GREEN ok +tcP4stuck_P4 expected=RED observed=RED ok [P4-STUCK,P4S] +tcP4ladder_All expected=GREEN observed=GREEN ok +tcP4leak_P1 expected=RED observed=RED ok [Deadlock detected,P4L] +tcP4release_All expected=GREEN observed=GREEN ok +SWEEP-DONE cells=47 mismatches=0 diff --git a/formal/walker/walker.pproj b/formal/walker/walker.pproj new file mode 100644 index 000000000..321cb3dab --- /dev/null +++ b/formal/walker/walker.pproj @@ -0,0 +1,9 @@ + +walker + + ./PSrc/ + ./PSpec/ + ./PTst/ + +./PGenerated + From 7594b61e8a72a2060165d9343066baf5d89e9cef Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Mon, 31 Aug 2026 15:35:34 -0600 Subject: [PATCH 02/12] formal: address review round 1 All eleven findings from the two automated review passes verified and dispositioned: bake-off cells split out of sweep.sh into a committed tools/bakeoff.sh (re-run 12/12 clean) so the test-plan command can no longer overwrite the frozen 66-cell evidence; both CALIBRATION.md status blocks rewritten to match their own committed evidence (walker 55-cell gate named, graph 66-cell freeze + completed bake-off named); the missing tc1c_P1_probe calibration row added; five-vs-seven policy count drift fixed across the coalescing note, refimpl comments, and policy-module fixture comments; policy 2's by-design cross-attempt regrounding blindness documented at ev_resume and in TRACE_BRIDGE.md; the dead structural-clear renderer branch now has an instrument-validation test; the vacuous non-member refusal control now runs against a module with a working positive; dead code in compression_test.go deleted; the stray 921KB solver checkpoint dropped and ignored; the Go 1.26 toolchain requirement documented. Affected host tests green; bake-off re-run through the new script, BAKEOFF-DONE cells=12 mismatches=0. Co-authored-by: Cursor --- formal/.gitignore | 7 ++- formal/graph/CALIBRATION.md | 30 +++++++---- .../graph/PCheckerOutput/bakeoff/summary.txt | 1 + formal/graph/tools/bakeoff.sh | 50 +++++++++++++++++++ formal/graph/tools/sweep.sh | 12 ----- formal/occult/README.md | 9 ++-- formal/occult/TRACE_BRIDGE.md | 13 +++++ formal/occult/host/compression_test.go | 5 -- .../host/constrained_params_probe_test.go | 17 +++++-- formal/occult/host/real_trace_oracle_test.go | 41 +++++++++++++-- formal/occult/host/refimpl_oracle_test.go | 4 +- formal/occult/src/sync_trace_policies.occult | 20 +++++++- ...e_axiom_fire.occult.occult.checkpoint.json | 7 --- formal/walker/CALIBRATION.md | 37 ++++++++------ 14 files changed, 188 insertions(+), 65 deletions(-) create mode 100755 formal/graph/tools/bakeoff.sh delete mode 100644 formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json diff --git a/formal/.gitignore b/formal/.gitignore index 6bcb02656..2a37be78b 100644 --- a/formal/.gitignore +++ b/formal/.gitignore @@ -3,7 +3,10 @@ PGenerated/ PCheckerOutput/ # Machine-replay counterexample archives (~200k lines across the -# calibrated reds). Regenerate any cell's replay with +# calibrated reds). Regenerate any cell's counterexample with # `p check -tc ` per the run log; the committed evidence is the -# human-readable counterexample.txt per cell plus the sweep summaries. +# sweep summaries. trace.json +# Occult engine solver checkpoints (regenerable tool output, ~1MB of +# base64 solver state per probe run). +*.checkpoint.json diff --git a/formal/graph/CALIBRATION.md b/formal/graph/CALIBRATION.md index 0a72b77ec..31167123b 100644 --- a/formal/graph/CALIBRATION.md +++ b/formal/graph/CALIBRATION.md @@ -1,18 +1,24 @@ # Graph model calibration — run log -Status: G1 and G2 families calibrated (30 cells; the 26-cell 10k -gate sweep ran clean and the 4 flap-back/G-pending additions were -calibrated individually — the next full-matrix sweep is the gate -after G3+). FLAP-BACK MACHINERY: the upstream reports CONTENT +Status: COMPLETE. All scenario families (G1–G9) built and +calibrated; the frozen 66-cell full-matrix sweep PASSED (see +§"Freeze sweep — 2026-08-30" below; run of record +`PCheckerOutput/sweep/summary.txt`, `SWEEP-DONE cells=66 +mismatches=0`; reproduce with `tools/sweep.sh`), and the 12-cell +bake-off phase matched its GS-CO-005 declared verdicts 12/12 (see +§"Bake-off results — 2026-08-30" below; run of record +`PCheckerOutput/bakeoff/summary.txt`; reproduce with +`tools/bakeoff.sh`). The verdict synthesis lives in `BAKEOFF.md`. +FLAP-BACK MACHINERY: the upstream reports CONTENT epochs everywhere (raw epochs never escape it), so `flapBack` (raw e>=3 serves content(e1)) keeps validators, manifests, folds, and SealExpect worlds coherent with no monitor changes. Spec baseline: -`formal/GRAPH_MODEL_SPEC.md` v4 FROZEN + GS-CO-001..004 (all four -change orders were driven by calibration finds in this build-out; -see §12 of the spec and the "Model decisions of record" section -below). Remaining scenario families (G3–G9, bake-off counts) are -pending — see Pending. +`formal/GRAPH_MODEL_SPEC.md` v4 FROZEN + GS-CO-001..005 (the first +four change orders were driven by calibration finds in this +build-out — see §12 of the spec and the "Model decisions of record" +section below; GS-CO-005 is the pre-registered bake-off decision +rule). Toolchain: P 3.1.0 (`p compile` / `p check -tc -s `), same conventions as `formal/walker/CALIBRATION.md`: verdicts are @@ -380,7 +386,11 @@ blocks Axis-3 citation until dispositioned (GS-CO-005(d)). ### Bake-off results — 2026-08-30, 12/12 match declarations 10k schedules per cell, uniform random, one run (summary archived at -`PCheckerOutput/bakeoff/summary.txt`). All four v1 controls GREEN +`PCheckerOutput/bakeoff/summary.txt`; reproduce with +`tools/bakeoff.sh`, which carries exactly these 12 cells — they are +deliberately NOT in `tools/sweep.sh`, so re-running the calibration +sweep cannot overwrite this phase's evidence and vice versa). All +four v1 controls GREEN (the zero-crash redo floor is bound 1 under BOTH variants — the count oracle measures crash-caused redo, not variant overhead); both G6b bound-1 probes RED on EXEC-BOUND (the mutation chassis's redo is diff --git a/formal/graph/PCheckerOutput/bakeoff/summary.txt b/formal/graph/PCheckerOutput/bakeoff/summary.txt index 13af1e9b8..b9f445f78 100644 --- a/formal/graph/PCheckerOutput/bakeoff/summary.txt +++ b/formal/graph/PCheckerOutput/bakeoff/summary.txt @@ -10,3 +10,4 @@ tcG5dE_W2 expected=RED observed=RED ok tcG5dS_W2 expected=RED observed=RED ok tcG5dE_W3 expected=GREEN observed=GREEN ok tcG5dS_W3 expected=GREEN observed=GREEN ok +BAKEOFF-DONE cells=12 mismatches=0 diff --git a/formal/graph/tools/bakeoff.sh b/formal/graph/tools/bakeoff.sh new file mode 100755 index 000000000..8e37f1f4b --- /dev/null +++ b/formal/graph/tools/bakeoff.sh @@ -0,0 +1,50 @@ +#!/usr/bin/env bash +# Bake-off phase cells (GS-CO-005 declared verdicts), kept OUT of the +# calibration sweep: sweep.sh reproduces the frozen 66-cell matrix +# (PCheckerOutput/sweep/summary.txt) and this script reproduces the +# 12-cell bake-off run of record (PCheckerOutput/bakeoff/summary.txt) +# without either overwriting the other's evidence. +# +# Usage: tools/bakeoff.sh [schedules] (run from formal/graph) +set -u +S="${1:-10000}" +OUT="PCheckerOutput/bakeoff" +SUMMARY="$OUT/summary.txt" +mkdir -p "$OUT" +: > "$SUMMARY" + +# cell:expected (RED = counterexample expected, GREEN = none). +CELLS=" +tcG6aE_Ctl:GREEN +tcG6aS_Ctl:GREEN +tcG6cE_Ctl:GREEN +tcG6cS_Ctl:GREEN +tcG6bE_Redo:RED +tcG6bS_Redo:RED +tcG5dE_W1:RED +tcG5dS_W1:RED +tcG5dE_W2:RED +tcG5dS_W2:RED +tcG5dE_W3:GREEN +tcG5dS_W3:GREEN +" + +mismatches=0 +total=0 +for entry in $CELLS; do + rest="${entry#*:}" + cell="${entry%%:*}" + expected="${rest%%:*}" + strategy="" + case "$rest" in *:*) strategy="${rest#*:}";; esac + total=$((total + 1)) + rm -rf "$OUT/$cell" + # shellcheck disable=SC2086 + p check -tc "$cell" -s "$S" ${strategy/=/ } -o "$OUT/$cell" > "$OUT/$cell.log" 2>&1 + ce=$(ls "$OUT/$cell"/BugFinding/graph_[0-9]*_[0-9]*.txt 2>/dev/null | head -1) + if [ -n "$ce" ]; then observed="RED"; else observed="GREEN"; fi + if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi + line="$cell expected=$expected observed=$observed $mark" + echo "$line" | tee -a "$SUMMARY" +done +echo "BAKEOFF-DONE cells=$total mismatches=$mismatches" | tee -a "$SUMMARY" diff --git a/formal/graph/tools/sweep.sh b/formal/graph/tools/sweep.sh index c062875a4..a0c4e6142 100755 --- a/formal/graph/tools/sweep.sh +++ b/formal/graph/tools/sweep.sh @@ -66,18 +66,6 @@ tcG6aE_Redo:RED tcG6aS_Redo:RED tcG6cE_Redo:RED tcG6cS_Redo:RED -tcG6aE_Ctl:GREEN -tcG6aS_Ctl:GREEN -tcG6cE_Ctl:GREEN -tcG6cS_Ctl:GREEN -tcG6bE_Redo:RED -tcG6bS_Redo:RED -tcG5dE_W1:RED -tcG5dS_W1:RED -tcG5dE_W2:RED -tcG5dS_W2:RED -tcG5dE_W3:GREEN -tcG5dS_W3:GREEN tcG7_Ladder:GREEN tcG7_Stuck:RED tcG8b_All:GREEN diff --git a/formal/occult/README.md b/formal/occult/README.md index ea8f86060..a259a32a1 100644 --- a/formal/occult/README.md +++ b/formal/occult/README.md @@ -63,9 +63,12 @@ cd formal/occult/host && go test -timeout 30m ./... when run together.) Requires the sibling engine checkout at `../occult` (the go.mod -`replace` points there). The pure `.occult` sources carry no Go -dependency; baton-sdk's public module does not require the engine -repo. +`replace` points there) and a Go 1.26 toolchain: the engine's own +go.mod pins `go 1.26.0`, so the host module pins it too — +deliberately ahead of the SDK root's 1.25.2 (a 1.25 toolchain with +auto-switching, `GOTOOLCHAIN=auto`, fetches 1.26 on its own). The +pure `.occult` sources carry no Go dependency; baton-sdk's public +module does not require the engine repo. ## Deliverable status diff --git a/formal/occult/TRACE_BRIDGE.md b/formal/occult/TRACE_BRIDGE.md index e9bbc45b0..86a5b678e 100644 --- a/formal/occult/TRACE_BRIDGE.md +++ b/formal/occult/TRACE_BRIDGE.md @@ -140,6 +140,19 @@ preserving; the engine's evaluation cost grows steeply with event count), and the structural clear is once per scope per SYNC, attempts included, granted to the scope's first WRITE (upsert or delete). +Division-of-labor note for the one-term rendering: clear grounding +persists across `ev_resume` BY DESIGN (committed rows survive the +crash), so in a whole-sync term an attempt-1 clear legitimately +grounds an attempt-2 write and policy 2 cannot red the +resume-without-regrounding class here. That class is covered on the +refimpl leg, which renders each attempt as its own term — a resumed +attempt writing without its own grounding reds clear-before-upsert +(`TestRefImplLegacyCrashResume`) — and its record-flavor incarnation +(the verdict-flip union) is a CONTENT violation owned by the +exporting test's content oracle, per the scope note below. The +policy module carries the same statement at its `ev_resume` +declaration. + The delete leg is fixtured too: `warm_replay_sync_tombstone.jsonl` records a warm delta round that replays the base, overlay-upserts one row, tombstones a departed row, and publishes — B3's within-page diff --git a/formal/occult/host/compression_test.go b/formal/occult/host/compression_test.go index 14d851b1f..b3ca2af4c 100644 --- a/formal/occult/host/compression_test.go +++ b/formal/occult/host/compression_test.go @@ -76,11 +76,6 @@ func TestL9bBucketAlignedLivenessProvable(t *testing.T) { // cur even AND s <= cur AND floor2(s) >= floor2(cur) -> s = cur for s := 0; s < genBound; s++ { for cur := 0; cur < genBound; cur += 2 { - src := implSource( - `%[1]d <= %[2]d`, - `classify (`+floor2s+` >= `+floor2c+`) { {true,} : "inner", Bool : "vac" } == "vac"`, - s, cur) - _ = src // premise chain is easier read as two explicit classifies below full := fmt.Sprintf( `classify (%[1]d <= %[2]d) { {true,} : classify ((%[1]d - %[1]d %% 2) >= (%[2]d - %[2]d %% 2)) { {true,} : classify (%[1]d == %[2]d) { {true,} : "ok", Bool : "violated" }, Bool : "ok" }, Bool : "ok" }`, s, cur) diff --git a/formal/occult/host/constrained_params_probe_test.go b/formal/occult/host/constrained_params_probe_test.go index 9ab77c545..0c1c08220 100644 --- a/formal/occult/host/constrained_params_probe_test.go +++ b/formal/occult/host/constrained_params_probe_test.go @@ -144,6 +144,10 @@ probe_go(tcons(ev_b(s), r), ff) = "violation: b-before-a"; ∃ probe_green; probe_green = tcons(ev_a(1), tcons(ev_b(2), tnil)); + +∃ bogus; +∃ probe_rogue; +probe_rogue = tcons(ev_a(bogus), tnil); ` // probeEval loads module src as name and evaluates M.probe(term), @@ -182,10 +186,17 @@ func TestConstrainedParamsBuiltinClassifierWorks(t *testing.T) { } // TestConstrainedParamsGateRefusesNonMembers pins that the gate is -// enforced at dispatch, not advisory lint metadata: a trace carrying a -// declared-but-non-member scope does not reduce to a verdict. +// enforced at dispatch, not advisory lint metadata. The refusal is +// asserted against probeBuiltinSrc — the module with a WORKING +// positive (TestConstrainedParamsBuiltinClassifierWorks reduces +// probe_green on it) — so non-reduction of the rogue trace can only +// mean the Number gate refused the non-numeric payload, not that the +// module never reduces anything. (Asserting refusal on +// probeConstrainedSrc would be vacuous: nothing reduces under it — +// that is exactly the gap TestConstrainedParamsUserspaceMembershipNotConsumed +// pins.) func TestConstrainedParamsGateRefusesNonMembers(t *testing.T) { - if v, ok := probeEval(t, "probe_constrained", probeConstrainedSrc, "M.probe_rogue"); ok { + if v, ok := probeEval(t, "probe_builtin", probeBuiltinSrc, "M.probe_rogue"); ok { t.Fatalf("non-member scope reduced to %q: constraints are not gating dispatch", v) } } diff --git a/formal/occult/host/real_trace_oracle_test.go b/formal/occult/host/real_trace_oracle_test.go index 247d0b687..3e6afd7bb 100644 --- a/formal/occult/host/real_trace_oracle_test.go +++ b/formal/occult/host/real_trace_oracle_test.go @@ -53,9 +53,12 @@ // lines between attempt segments, rendered as ev_resume. // - Checkpoint coalescing: a run of consecutive checkpoints renders // as ONE ev_checkpoint. Verdict-preserving by inspection of all -// five policies: four pass checkpoints through untouched and the -// fifth (checkpoint-before-progress) sets an idempotent flag, so -// back-to-back checkpoints are indistinguishable from one. Needed +// seven policies: five pass checkpoints through untouched +// (policies 1-3 and 5 by explicit pass-through rules; policy 7's +// epg_go likewise), checkpoint-before-progress sets an idempotent +// flag, and session_ckpt_consistency's scc_go commits the +// uncommitted-write flag — after the first checkpoint the flag is +// ff, so an immediately following checkpoint is a no-op. Needed // because the engine's term evaluation cost grows steeply with // event count (a 25-event trace exceeds 18 minutes per cell; 14 // events evaluate in tens of seconds). @@ -67,6 +70,7 @@ import ( "fmt" "os" "path/filepath" + "strings" "testing" ) @@ -394,3 +398,34 @@ func TestRealTraceBridgeCatchesStaleExternalSurvivor(t *testing.T) { t.Errorf("planted stale external survivor not caught, verdict %q", verdict) } } + +// TestRealTraceBridgeStructuralClearInsertion validates the renderer's +// structural-clear branch — the ONE place the bridge synthesizes +// grounding the recorder never observed (a non-resumed trace's +// partitions are born empty at StartNewSync). Every committed fixture +// now emits an explicit clear before its first write (record-round +// grounding made replacement clears real), so without this test the +// branch is dead across the suite and a regression in it would +// silently green a genuinely un-grounded write. The synthetic event +// list has no explicit clear anywhere and spans a resume: the renderer +// must insert ev_clear exactly ONCE for the scope (per sync, not per +// attempt — the partition is born empty once) and clear_before_upsert +// must answer ok for that reason. +func TestRealTraceBridgeStructuralClearInsertion(t *testing.T) { + header := realTraceHeader{Name: "synthetic_structural_clear", Resumed: false} + events := []realTraceEvent{ + {Kind: "upsert", RowKind: "grant", ScopeKey: "k"}, + {Kind: "resume"}, + {Kind: "upsert", RowKind: "grant", ScopeKey: "k"}, + } + term := renderRealTrace(t, header, events) + if n := strings.Count(term, "ev_clear"); n != 1 { + t.Fatalf("structural clear must be synthesized exactly once per scope per sync, found %d in %s", n, term) + } + if !strings.HasPrefix(term, "M.tcons(M.ev_clear(M.s1)") { + t.Fatalf("structural clear must precede the first write, term %s", term) + } + if verdict := policyVerdictTerm(t, "clear_before_upsert", term); verdict != "ok" { + t.Errorf("structurally grounded sync-birth trace must satisfy clear_before_upsert, got %q", verdict) + } +} diff --git a/formal/occult/host/refimpl_oracle_test.go b/formal/occult/host/refimpl_oracle_test.go index b9ea37f6b..16c9fcaba 100644 --- a/formal/occult/host/refimpl_oracle_test.go +++ b/formal/occult/host/refimpl_oracle_test.go @@ -4,7 +4,7 @@ // - CONTENT oracle (Go): the sealed artifact must equal upstream at // the head epoch. // - TRACE oracle (engine): every attempt's canonical trace is checked -// against all five deliverable-7 policies. +// against all seven deliverable-7 policies. // // The matrix this asserts: // @@ -48,7 +48,7 @@ func phantomConfig(mode refimpl.Mode, crash bool) refimpl.Config { var truthAtHead = map[string]string{"id2": "v2"} var phantomArtifact = map[string]string{"id1": "vx", "id2": "v2"} -// checkAttempts runs every attempt trace through all five policies and +// checkAttempts runs every attempt trace through all seven policies and // asserts the expected verdict: expectViolation maps attempt index // (0-based) to the one policy that must fire; every other cell must be // "ok". diff --git a/formal/occult/src/sync_trace_policies.occult b/formal/occult/src/sync_trace_policies.occult index 7ecdef963..51ad29d0f 100644 --- a/formal/occult/src/sync_trace_policies.occult +++ b/formal/occult/src/sync_trace_policies.occult @@ -100,6 +100,22 @@ syntax("standard"); # B5-legal at-least-once idempotence, while a within-attempt duplicate # remains the bug the policy exists to catch. The quiescent-checkpoint # flag also persists: a resume adds no progress by itself. +# +# CONSEQUENCE, stated so nobody reads more into policy 2 than it says: +# because clear grounding persists across ev_resume, an attempt-1 +# clear legitimately grounds an attempt-2 write in a ONE-TERM +# multi-attempt trace — committed rows really do survive the crash, so +# that history is ordering-legal. Policy 2 is therefore BY DESIGN +# blind to the resume-without-regrounding class when a whole sync +# renders as one term. That class is caught on the other leg of the +# bridge: the refimpl oracle renders EACH ATTEMPT as its own term (no +# ev_resume), where a resumed attempt writing without its own clear +# reds clear-before-upsert (TestRefImplLegacyCrashResume), and the +# real-trace renderer inserts no structural clear for resumed +# fixtures. The record-flip incarnation (fresh RECORD round over a +# durably-grounded partition holding crashed-copy debris) is a CONTENT +# violation, owned by the exporting test's content oracle — see +# TRACE_BRIDGE.md's scope note. ∃ ev_resume; # Scopes and trace list constructors. @@ -385,7 +401,7 @@ epg_go(tcons(ev_sread_miss(k), r), n, c1, c2, l1, l2) = epg_go(r, n, c1, c2, l1, trace_green = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s1), tcons(ev_upsert(s1), tcons(ev_publish(s1), tcons(ev_checkpoint, tcons(ev_seal, tnil))))))); # Each red fixture violates EXACTLY its own policy and satisfies the -# other four (the isolation matrix is asserted by the host). +# other six (the isolation matrix is asserted by the host). ∃ trace_red_cbr; trace_red_cbr = tcons(ev_clear(s1), tcons(ev_replay(s1), tnil)); ∃ trace_red_cbu; @@ -409,7 +425,7 @@ trace_green_resume = tcons(ev_consult(s1), tcons(ev_clear(s1), tcons(ev_replay(s # red_ops_resume: a WITHIN-attempt duplicate copy after a resume must # still violate once-per-scope — the reset is per boundary, not an -# amnesty. Satisfies the other four (no upserts, no seal). +# amnesty. Satisfies the other six (no upserts, no seal). ∃ trace_red_ops_resume; trace_red_ops_resume = tcons(ev_consult(s1), tcons(ev_replay(s1), tcons(ev_resume, tcons(ev_consult(s1), tcons(ev_replay(s1), tcons(ev_replay(s1), tnil)))))); diff --git a/formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json b/formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json deleted file mode 100644 index 546bd47f4..000000000 --- a/formal/occult/tests/probe_axiom_fire.occult.occult.checkpoint.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "version": 2, - "savedAtUtc": "2026-08-31T02:55:14.19044Z", - "sourceSha256": "a0c5d6a8f5445b04e4f5c3c54f58df6774f6fa29a238b7536ebd0c8bb4db0044", - "solverType": "*solve.CompositeSolver", - "payloadB64": "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" -} \ No newline at end of file diff --git a/formal/walker/CALIBRATION.md b/formal/walker/CALIBRATION.md index 5d91d5956..37ab9f72d 100644 --- a/formal/walker/CALIBRATION.md +++ b/formal/walker/CALIBRATION.md @@ -1,26 +1,30 @@ # Walker calibration — run log -Status: COMPLETE at the v11 freeze + MS-CO-001, extended post-freeze -with the P6-C session-checkpoint-consistency tranche (three cells, -decision 25 — the CO-6b-009 root cause made executable; sweep now 50 -cells). Scenarios 1, 2, 3, 4, -5 (both triggers + crash window + C1 probe), 6 (both flavors + the -round-7 third-placement cell + the MS-CO-001 o-iv mutant), 7, and the -P4 progress cells built and calibrated. Spec baseline: -`formal/MODEL_SPEC.md` v11, FROZEN +Status: COMPLETE. CURRENT GATE: the 55-cell full-matrix sweep, 0 +mismatches, every red on its calibrated alarm (`tools/sweep.sh`, 10k +schedules per cell; the run of record is +`PCheckerOutput/sweep/summary.txt`, ending +`SWEEP-DONE cells=55 mismatches=0`). Scenarios 1, 2 (including the +P6-C session-checkpoint-consistency tranche, decision 25 — the +CO-6b-009 root cause made executable), 3, 4, 5 (both triggers + crash +window + C1 probe), 6 (both flavors + the round-7 third-placement +cell + the MS-CO-001 o-iv mutant), 7, 8 (external principals, +decision 26), and the P4 progress cells built and calibrated. Spec +baseline: `formal/MODEL_SPEC.md` v11, FROZEN (round-7 dispositions + de-scope edits applied; see the §11 v11 entry), plus change order MS-CO-001 (dispositions for the PARALLEL round-7 review — `reviews/model-spec-round7-overlay-parallel.md` — surfaced post-freeze; §3/§4/§5 registration edits, the per-verdict deferral scoping, and the o-iv-removal kill cell). The v11 monitor -pins (F2 complete-rounds replacement -counting, F3 attestation-over-empty-fold) and the two v11 cells -(6-overlay-last, 3-atomic) are built and verified. FREEZE SWEEP: -all 46 cells, 0 mismatches, every red on its calibrated alarm -(`tools/sweep.sh`, 10k schedules per cell; summary archived at -`traces/freeze-sweep-v11-summary.txt`). The pre-v11 44-cell sweep was -also clean, isolating the P4 merge from the v11 monitor change; the -post-MS-CO-001 47-cell sweep is the current gate. +pins (F2 complete-rounds replacement counting, F3 +attestation-over-empty-fold) and the two v11 cells (6-overlay-last, +3-atomic) are built and verified. Sweep history (superseded gates, +summaries archived under `traces/`): the 46-cell v11 freeze sweep +(`traces/freeze-sweep-v11-summary.txt`; the pre-v11 44-cell sweep was +also clean, isolating the P4 merge from the v11 monitor change), the +47-cell post-MS-CO-001 sweep +(`traces/msco001-sweep-summary.txt`), then +3 P6-C cells (50) and ++5 scenario-8 cells (the current 55). Toolchain: P 3.1.0 (`p compile` / `p check -tc -s `). Counterexample traces are NOT committed (neither the human-readable @@ -49,6 +53,7 @@ strategy at ~60 schedules, missed by the 100k random pass). | tc1bii_P1 | carrier validator-less | P1 | RED | RED: `P1-CONTENT` (the attestation-only 1b-ii edge is also live in this config; the checker surfaces the content shape first) | first find | | tc1c_P1 | carrier-less hard crash | P1 | RED | RED: `P1-CONTENT` (copy debris survives restart-from-root; fresh round unions over it) | first find | | tc1c_P2 | crash + verification sync | P2 | RED | RED: `P2-STALENESS` | first find | +| tc1c_P1_probe | tc1c's verification config (3 syncs), P1 asserted | P1 | RED | RED: `P1-CONTENT` — premise-liveness probe: the verify config still contains the sync-2 union, so tc1c_P2's red is fired by the staleness mechanism, not by the premise having drifted out of the config | first find | | tcGreen_All | no interruption, no mutation, honest replay | P1+P2+P3′ | GREEN | GREEN | 10000 schedules | | tc1c_P2_honest | crash config, P2 only, 2 syncs | P2 | GREEN | GREEN (the corrupted seal itself is staleness-legal; the alarm belongs to the verification sync) | 3000 schedules | From 7fb1082d50097a2c232cd6aaffbcba28b93c41b8 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Mon, 31 Aug 2026 16:06:48 -0600 Subject: [PATCH 03/12] formal: disposition round-2 findings (independent model reviews) Nine real findings from two independent static reviews, none verdict-flipping: TRACE_BRIDGE Mapping 1 rewritten against the actual announce vocabularies and labeled prose-only with a renderer-hazard warning; MS-CO-002 registered (torn rounds are stop-reachable, monitor-side exclusion, P3-prime narrowing recorded at spec, calibration, and code); graph digest session-field vacuity declared per SPEC 4a's closure clause; refimpl emits ev_delete and drops a dead field (all four scenarios re-run green through seven policies); policy 1 header and policy 5 scope corrected; REPORT red-pin overclaim, tc3a_P1 observed alarm, capable-engine fixture description, projection order dependency, and one five-vs-seven leftover fixed. Co-authored-by: Cursor --- formal/MODEL_SPEC.md | 34 ++++++++---- formal/REPORT.md | 12 ++-- formal/graph/CALIBRATION.md | 15 +++++ formal/occult/README.md | 2 +- formal/occult/TRACE_BRIDGE.md | 58 ++++++++++++++------ formal/occult/host/real_trace_oracle_test.go | 11 +++- formal/occult/host/refimpl/refimpl.go | 13 +++-- formal/occult/src/sync_trace_policies.occult | 25 +++++++-- formal/walker/CALIBRATION.md | 26 +++++---- formal/walker/PSpec/Monitors.p | 6 ++ 10 files changed, 151 insertions(+), 51 deletions(-) diff --git a/formal/MODEL_SPEC.md b/formal/MODEL_SPEC.md index 94ff96b89..b6d67339e 100644 --- a/formal/MODEL_SPEC.md +++ b/formal/MODEL_SPEC.md @@ -575,18 +575,32 @@ response, the attempt's config) — §2.4. round's verdict epoch (plan B5 permits the replay page to publish the new delta token before overlay pages land, so no content check at publish). The phantom union fails content or attestation in every §9 - variant; case 4's duplicate copy violates the at-most-one-replacement - rule directly; case 5a's drift copy fails config. BOUNDARY: TORN +variant; case 4's duplicate copy violates the at-most-one-replacement +rule directly; case 5a's drift copy fails config. BOUNDARY: TORN completed rounds are outside P1-content's designed domain — under between-attempt mutation a torn fresh round legally mixes epochs - (pure smear) and the per-round fold would false-alarm. No §9 config - can tear a round (each config's single stop is consumed by its - premise, each schedules at most one mutation, and crash-based - configs — scenario 6 — cannot tear: crash-only histories resume - from root-token checkpoints, §3/§5), so no scripted - verdict is affected; widening any config to a second interruption - plus a second mutation REQUIRES a fold extension for torn rounds - (per-page folding) via change order first. + (pure smear) and the per-round fold would false-alarm. AMENDED per + MS-CO-002 (build-out find; decision 1 of the calibration log's + "Model decisions of record"): this spec originally argued no §9 + config can tear a round (each config's single stop consumed by its + premise), but in the model the stop's PLACEMENT is genuinely + explored, so torn rounds ARE reachable (graceful stop mid-fresh- + round, resumed in attempt 2; crash-based configs still cannot tear — + crash-only histories resume from root-token checkpoints, §3/§5). + The exclusion is therefore enforced MONITOR-SIDE, not config-side: + P1 tracks attempt ghosts per round across every round op + (clear/copy/upsert/tombstones/publish) and excludes torn scopes + from the content and attestation folds. KNOWN NARROWING, registered + here: P3′'s torn tracking observes only overlay writes + (upsert/tombstones), so a replacement-only tear is excluded from + P1-content but not from P3′'s domain; no calibrated cell reaches a + replacement-only tear that survives to a P3′-asserted seal (the + P3′-asserting interrupted cells seal empty or use atomic/overlay + shapes), and widening P3′'s tracking to the P1 op set is the + registered follow-up if one ever does. Widening any config to a + second interruption plus a second mutation still REQUIRES a fold + extension for torn rounds (per-page folding) via change order + first. - **P2 — bounded staleness (safety, multi-sync).** Ghost provenance per row: origin epoch and the chain of syncs it traveled by replay. "Consulted against upstream during sync N" is pinned as: the scope diff --git a/formal/REPORT.md b/formal/REPORT.md index 430ca6b2d..8f15616fa 100644 --- a/formal/REPORT.md +++ b/formal/REPORT.md @@ -18,10 +18,14 @@ its own, is verified at small scope in both lineage variants, and the registered decision rule selects **variant S (observable-causal stamps)** — see `graph/BAKEOFF.md`. The shipped syncer's real commit-order behavior has been witnessed conformant to the ordering -and durability policies on every execution we exported (cold, warm, -crash/resume, tombstone-delta), and the instrument is sharp enough -that it falsified one piece of documented resume behavior along the -way. +and durability policies on every honest execution we exported (cold, +warm, crash/resume, tombstone-delta, record-flip, external +principals); two exported fixtures are STANDING RED PINS by design — +the session-zombie trace under session-checkpoint consistency +(finding 0) and the SQLite external-principal trace under +external-principal grounding (the accepted degrade) — and the +instrument is sharp enough that it falsified one piece of documented +resume behavior along the way. ## Track A — calibration model of the current design (P) diff --git a/formal/graph/CALIBRATION.md b/formal/graph/CALIBRATION.md index 31167123b..382c45cd9 100644 --- a/formal/graph/CALIBRATION.md +++ b/formal/graph/CALIBRATION.md @@ -184,6 +184,21 @@ tcG1iii_S / tcG2s_All / tcG2awS_All / tcG2fbS_All). names a dead generation. Honest mechanisms (E resume purge, S dispatch refusal) make it unreachable on every cell, so it is asserted in the honest G5 greens, not just the kill. +5. **Digest session fields are DECLARED VACUITY in this envelope + (SPEC §4a DIGEST CLOSURE discharge).** `tDigest` carries the + session-read fields the spec requires + (`sVal`/`sWriter`/`sWGen`/`hasSess`), but every digest the model + constructs uses the no-session sentinel (`NodeExec.p`): no + adopt-eligible node performs a pre-commit session read in any + calibrated cell — readers always fetch fresh and never consult + markers, writers are writer-ineligible (pubBearing), and the + consult-kind adopt check precedes any session read. Per the + spec's own closure clause this omission is registered vacuity, + not an escape: any extension that gives an adopt-eligible node a + pre-commit session read MUST populate the digest fields (and add + a cell where a session-value change kills adoption) or it + reopens exactly the E-only-laundering class the digest exists to + refuse. ## G3 / G4 / G6-G9 — built and calibrated diff --git a/formal/occult/README.md b/formal/occult/README.md index a259a32a1..4a0aa1c94 100644 --- a/formal/occult/README.md +++ b/formal/occult/README.md @@ -142,7 +142,7 @@ known-good one: is NOT the epoch it claims to be. - EXECUTABLE (`refimpl_oracle_test.go` + `host/refimpl/`): the demand-graph reference implementation runs the same scenario to seal - — content matches upstream and every attempt trace passes all five + — content matches upstream and every attempt trace passes all seven policies, with and without a crash. In legacy mode the sealed artifact carries the phantom row: on a clean run the ordering policies are (correctly) blind to it — the composition class belongs diff --git a/formal/occult/TRACE_BRIDGE.md b/formal/occult/TRACE_BRIDGE.md index 86a5b678e..3508aa23c 100644 --- a/formal/occult/TRACE_BRIDGE.md +++ b/formal/occult/TRACE_BRIDGE.md @@ -60,32 +60,56 @@ recon-before-copy violation. Pending extension, tracked not modeled: generation stamps (the graph model's variant-S lineage). -## Mapping 1: P model announce events +## Mapping 1: P model announce events — PROSE ONLY (no renderer) + +STATUS: this mapping is a documented convention, not an implemented +instrument — `host/` carries no P-trace renderer (only +`renderRealTrace` for Mapping 2 and `refimpl.RenderOccult` for the +reference implementation). A P counterexample is judged today by +reading it against this table by hand; anyone automating it must +build the renderer from the ACTUAL announce vocabularies below and +add a planted-seal validation test (a renderer that fails to emit +`ev_seal` silently vacates the seal-anchored policies 4, 5, and 7, +which are green-by-prefix on seal-less traces). The walker and graph models announce through the monitor event vocabulary (`formal/walker/PSrc/Events.p`, `formal/graph/PSrc/Events.p`). A P counterexample trace renders onto the canonical list by keeping announce events in schedule order and dropping everything else: -| P announce | Canonical | +| P announce (walker / graph where they differ) | Canonical | |------------|-----------| | `eAnnConsult` | `ev_consult(s)` | -| `eAnnClear` / the clear leg of `eReplayUnit`/`eGReplayUnit` | `ev_clear(s)` | -| `eAnnReplay` (copy commit) | `ev_replay(s)` | +| `eAnnClear` (incl. the unit's clear constituent) | `ev_clear(s)` | +| `eAnnReplay` / `eAnnReplayCopy` (copy commit) | `ev_replay(s)` | | `eAnnUpsert` | `ev_upsert(s)` | -| `eAnnPublish` / `eGSessionPub` (artifact-facing) | `ev_publish(s)` | +| `eAnnTombstones` (one per removed id) | `ev_delete(s)` | +| `eAnnPublish` (artifact-facing publish only) | `ev_publish(s)` | | `eAnnCheckpoint` | `ev_checkpoint` | -| `eAnnSealed` | `ev_seal` | +| `eAnnSessionSet` | `ev_swrite(k)` | +| `eAnnSessionGet` / `eAnnSessionRead` (found: hit, else miss) | `ev_sread_hit(k)` / `ev_sread_miss(k)` | +| `eAnnSeal` / `eAnnGSeal` | `ev_seal` | + +Session-write REQUESTS (`eGSessionPub`) do not render: they are the +wire message to the store, and the canonical event is the store's +committed announce (`eAnnSessionSet`), same as every other write. +Session events map to the session keyspace (`ev_swrite`), never to +`ev_publish` — a session write is not an artifact publish. -The atomic units (`eReplayUnit`, `eOverlayUnit`, `eGOverlayUnit`) -expand to their leg order — clear, copy, marker, publish — because the -policies check the leg ordering that the units guarantee by -construction; running unit-built traces through the oracle is a -consistency check of that guarantee, not new information. Crash -scenarios cut the list at the crash point: a cut trace must still -satisfy the prefix-closed policies (1–3), while the seal-anchored -policies (4–5) are vacuous without `ev_seal` — exactly the -sync-scoped-freshness stance the models take. +The atomic units expand to their ANNOUNCE order, which differs by +model: the walker's `eReplayUnit`/`eOverlayUnit` announce clear, copy +(, upserts, tombstones), publish; the graph's +`eGReplayUnit`/`eGOverlayUnit` announce the marker put FIRST (the +P-MARK convention — see `graph/PSrc/Store.p`'s unit handlers), then +clear, copy, publish. Marker puts have no canonical event (generation +stamps are the tracked pending extension), so a rendered unit +contributes clear, copy, publish either way. The policies check the +leg ordering the units guarantee by construction; running unit-built +traces through the oracle is a consistency check of that guarantee, +not new information. Crash scenarios cut the list at the crash point: +a cut trace must still satisfy the prefix-closed policies (1–3), +while the seal-anchored policies (4–5) are vacuous without `ev_seal` +— exactly the sync-scoped-freshness stance the models take. ## Mapping 2: real sync executions — IMPLEMENTED @@ -244,7 +268,9 @@ engine records nothing), and `ep_copy` per committed principal write. Two fixtures are exported by the existing external-principal chaos tests: `external_resume_current_answer.jsonl` (five attempts, capable engine, shrink mid-sync — green on all seven policies: every -resume re-lists and reconciles before copying) and +attempt that COPIES does so only after a completed `ep_recon`; +mid-phase crash attempts re-list and are cut before reconciling, +which is legal — the recon gate binds copies, not lists) and `external_resume_sqlite_degrade.jsonl` — a STANDING KNOWN-DEGRADE PIN, expected `violation: ext-recon-before-copy`: SQLite cannot delete, the resume warns and copies the current answer over the dead attempt's diff --git a/formal/occult/host/real_trace_oracle_test.go b/formal/occult/host/real_trace_oracle_test.go index 3e6afd7bb..3134e6138 100644 --- a/formal/occult/host/real_trace_oracle_test.go +++ b/formal/occult/host/real_trace_oracle_test.go @@ -40,7 +40,16 @@ // policy tracks each principal independently, and the recon gate // is principal-agnostic (every attempt in the committed fixtures // copies the first-seen principal, so a missing ep_recon still -// fires on a kept copy). +// fires on a kept copy). ORDER DEPENDENCY, stated: the +// stale-survivor direction is only observable if the SHRINKING +// principal lands inside the p1/p2 envelope. The committed +// capable-engine fixture satisfies this (external-user-1 is +// second-seen and shrinks away; external-user-2 is projected +// out and stays live), and the dependency fails LOUDLY, not +// silently: if a regenerated fixture reordered first-seen so the +// shrinking principal were projected out, +// TestRealTraceBridgeCatchesStaleExternalSurvivor's planted +// verdict would come back "ok" and the test would fail. // - Structural clear: a trace that starts at sync birth // (header resumed=false) writes into partitions StartNewSync // created empty, so an upsert with no earlier explicit clear for diff --git a/formal/occult/host/refimpl/refimpl.go b/formal/occult/host/refimpl/refimpl.go index dfeb34b79..f1efcca3f 100644 --- a/formal/occult/host/refimpl/refimpl.go +++ b/formal/occult/host/refimpl/refimpl.go @@ -17,6 +17,12 @@ // module. The store commits writes durably as they happen (they survive // a crash); the checkpoint is the scheduler watermark, exactly the // walker/graph models' crash semantics. +// +// SCOPE: the runtime's premise-validated ADOPTION (marker consult on +// re-execution, GRAPH_MODEL_SPEC §4a) is deliberately NOT modeled — a +// resumed attempt re-executes the full round under the always-honest +// path. Adoption semantics are exercised by the P graph model's +// P-ADOPT cells, not here. package refimpl import ( @@ -37,7 +43,7 @@ const ( // Event is one canonical trace event (TRACE_BRIDGE.md vocabulary). type Event struct { - Kind string // consult, clear, replay, upsert, publish, checkpoint, seal + Kind string // consult, clear, replay, upsert, delete, publish, checkpoint, seal Scope string // "" for checkpoint/seal } @@ -111,7 +117,6 @@ const scope = "s1" // durable is the store state that survives a crash. type durable struct { partition map[string]string - hasMarker bool markerBase int // the replay unit's attested base epoch checkpoint bool // scope watermark: scope completed at Head } @@ -152,7 +157,6 @@ func runAttempt(cfg Config, st *durable, attempt int) (trace []Event, sealed boo for k, v := range cfg.Cache.Rows { st.partition[k] = v } - st.hasMarker = true st.markerBase = cfg.Cache.Base emit("clear", scope) emit("replay", scope) @@ -177,8 +181,7 @@ func runAttempt(cfg Config, st *durable, attempt int) (trace []Event, sealed boo } for _, k := range deletes { delete(st.partition, k) - // Tombstones have no canonical event yet (TRACE_BRIDGE.md - // pending extensions); the content oracle still sees them. + emit("delete", scope) } emit("publish", scope) diff --git a/formal/occult/src/sync_trace_policies.occult b/formal/occult/src/sync_trace_policies.occult index 51ad29d0f..926c4a1ee 100644 --- a/formal/occult/src/sync_trace_policies.occult +++ b/formal/occult/src/sync_trace_policies.occult @@ -130,7 +130,11 @@ syntax("standard"); # --- Policy 1: consult-before-replay --- # Every replay commit for a scope requires an earlier source-cache -# consult for that scope in the same attempt. +# consult for that scope in the same SYNC: the consult flags persist +# across ev_resume (the hit-set is checkpoint-durable, see the +# ev_resume note above), so a resumed attempt replaying under attempt +# 1's consult is legal. A within-sync replay with NO prior consult +# anywhere is the violation. ∃ consult_before_replay; ∃ cbr_go; consult_before_replay(t) = cbr_go(t, ff, ff); @@ -246,9 +250,22 @@ cbp_go(tcons(ev_seal, r), tt) = "ok"; cbp_go(tcons(ev_seal, r), ff) = "violation: checkpoint-before-progress"; # --- Policy 5: seal obligations --- -# Every scope with any activity this attempt (consult/clear/replay/ -# upsert) must be published before the seal. State per scope: active -# flag, published flag. +# Every scope with any activity this sync (consult/clear/replay/ +# upsert/delete) must be published before the seal. State per scope: +# active flag, published flag. +# +# SCOPE, stated deliberately: the obligation is EXISTENTIAL — some +# publish for the scope precedes the seal. A write AFTER the scope's +# last publish (publish, upsert, seal with no re-publish) still +# satisfies this policy: whether every row is covered by the +# attestation it sealed under is a CONTENT/attestation question, +# owned by the walker model's P1-ATTEST clauses and the exporting +# test's content oracle, not by this ordering policy. Strengthening +# this policy to "last write precedes last publish" is possible +# (reset the published flag on activity) but is registered as a +# deliberate non-goal while the real renderer's fixtures publish +# per-round: the weak form matches what commit order alone can +# witness. ∃ seal_obligations; ∃ so_go; seal_obligations(t) = so_go(t, ff, ff, ff, ff); diff --git a/formal/walker/CALIBRATION.md b/formal/walker/CALIBRATION.md index 37ab9f72d..dcfd4b5ca 100644 --- a/formal/walker/CALIBRATION.md +++ b/formal/walker/CALIBRATION.md @@ -15,7 +15,9 @@ baseline: `formal/MODEL_SPEC.md` v11, FROZEN entry), plus change order MS-CO-001 (dispositions for the PARALLEL round-7 review — `reviews/model-spec-round7-overlay-parallel.md` — surfaced post-freeze; §3/§4/§5 registration edits, the per-verdict -deferral scoping, and the o-iv-removal kill cell). The v11 monitor +deferral scoping, and the o-iv-removal kill cell) and MS-CO-002 (the +§7 torn-round amendment: tearing is stop-reachable, exclusion is +monitor-side — discharging decision 1 below). The v11 monitor pins (F2 complete-rounds replacement counting, F3 attestation-over-empty-fold) and the two v11 cells (6-overlay-last, 3-atomic) are built and verified. Sweep history (superseded gates, @@ -106,7 +108,7 @@ validators): | cell | config | property | expected | observed | budget | |---|---|---|---|---|---| -| tc3a_P1 | shipped (`hitValidatorBinding` ON) — the residual hole | P1 | RED | RED: `P1-ATTEST-SEAL` (carrier-last shape: rows(B) sealed under entry V_A; the carrier-first/interleaved content shape is also live in the config) — requires the re-consult's lookup-hit V_B to OVERWRITE the hit map before the carrier's LIVE hit read (last-write-wins rebind) | first find (0.34% of 10k — narrow: needs C dispatched after P's re-consult transition) | +| tc3a_P1 | shipped (`hitValidatorBinding` ON) — the residual hole | P1 | RED | RED: `P1-CONTENT` is the archived sweep's first find (carrier-first/interleaved content shape); the `P1-ATTEST-SEAL` carrier-last shape (rows(B) sealed under entry V_A) is also live in the config — both require the re-consult's lookup-hit V_B to OVERWRITE the hit map before the carrier's LIVE hit read (last-write-wins rebind) | first find (0.34% of 10k — narrow: needs C dispatched after P's re-consult transition) | | tc3a_P2 | same config | P2 | GREEN | GREEN — attempt 1's validation match qualifies the scope as consulted; copied rows carry hops 1 (corrected expectation; spec v2 wrongly claimed a P2 red) | 10000 schedules | | tc3b_P1 | pre-CO-6b-004 (`hitValidatorBinding` OFF), 1-page planning (cell 31) | P1 | RED | RED: `P1-ATTEST-SEAL` — no re-consult, hit stays V_A, NO binding check; carrier copies swapped B and publishes V_A | first find (100% of explored) | | tc3bBindingOn_All | same premise, binding ON — the CO-6b-004 kill | P1+P2+P3′ | GREEN | GREEN — binding gate compares hit V_A to base V_B, fails LOUD-COLD (behavior, not assert); scope seals empty in premise schedules, no wrong data | 10000 schedules | @@ -229,14 +231,18 @@ and meets the same drifted config: ## Model decisions of record (change-order candidates for the spec) -1. **Torn-round exclusion is monitor-side, not config-side.** The spec - (§7 boundary note) argued no §9 config can tear a round because each - config's single stop is consumed by its premise. In the model the - stop's placement is genuinely explored, so torn rounds ARE reachable - (stop mid-fresh-round, resumed in attempt 2). The monitors track - attempt ghosts per round and exclude torn scopes from P1-content and - P3′ rather than trusting configs. Spec §7 should be amended by - change order. +1. **Torn-round exclusion is monitor-side, not config-side + (DISCHARGED as MS-CO-002).** The spec (§7 boundary note) argued no + §9 config can tear a round because each config's single stop is + consumed by its premise. In the model the stop's placement is + genuinely explored, so torn rounds ARE reachable (stop + mid-fresh-round, resumed in attempt 2). The monitors track attempt + ghosts per round and exclude torn scopes from P1-content and P3′ + rather than trusting configs. Spec §7 now carries the amendment + (change order MS-CO-002), including the registered narrowing that + P3′'s torn tracking observes only overlay writes — a + replacement-only tear is P1-excluded but inside P3′'s domain; no + calibrated cell reaches one at a P3′-asserted seal. 2. **P2 corollary-run scoping** is realized as a config flag (`verificationOnlyIfInterrupted`): the verification sync runs only in histories where the scripted interruption landed. Without it, honest diff --git a/formal/walker/PSpec/Monitors.p b/formal/walker/PSpec/Monitors.p index 0f27a0e7d..ef2966c77 100644 --- a/formal/walker/PSpec/Monitors.p +++ b/formal/walker/PSpec/Monitors.p @@ -238,6 +238,12 @@ spec P3prime observes eAnnSyncStart, eAnnConsult, eAnnUpsert, eAnnTombstones, eA lastEpoch[p.scope] = p.epoch; } } + // Torn tracking here observes OVERLAY writes only — narrower + // than P1's every-round-op tracking. Replacement-only tears + // are P1-excluded but inside this monitor's domain; registered + // as the MS-CO-002 narrowing (no calibrated cell reaches one + // at a P3'-asserted seal). Widen to the P1 op set before + // adding any cell that could. on eAnnUpsert do (p: (syncN: int, scope: int, rows: seq[tRow], ghost: tRoundGhost)) { trackTorn(p.scope, p.ghost); } From 41978d6bddb3ebbcfce5b0a6dba84bc7c43e93d0 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Mon, 31 Aug 2026 16:10:53 -0600 Subject: [PATCH 04/12] formal: add make targets for the model sweeps and Occult suite Same change as the working branch: guarded wrappers (P checker, sibling ../occult checkout) for the sweeps, bake-off, and host suite; no installation targets. Co-authored-by: Cursor --- Makefile | 50 +++++++++++++++++++++++++++++++++++++++++++++++- formal/README.md | 7 +++++++ 2 files changed, 56 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index a625c37c6..a215c8e22 100644 --- a/Makefile +++ b/Makefile @@ -272,10 +272,11 @@ errorfs-soak: ## Sweep whole-sync Pebble crash points using errorfs. chaos-check: ## Run bounded representative chaos checks under race detection. go test -race -count=1 ./internal/chaosconnector/... go test -race -count=1 -timeout=10m -run '^TestChaosConnector(LostResponseThenFilesystemFailureResumes|ResourcesAndEntitlementsFaultMatrix|ListGrantsFaultMatrix|ReservedBatonIDOwnershipIsRejected|MalformedKnownAnnotationFailsWithoutSealing|ClearedNextPageTokenSealsOnlyVisiblePrefix|CancellationTerminatesAndColdResumes|DataPolicyLifecycleCorpus|ExternalPrincipalResumeUsesCurrentExternalAnswer|SQLiteExternalPrincipalResumeDegradesWithoutFailure|ExternalPrincipalCleanupUsesOnePassPerKeyspace)$$' ./pkg/sync + go test -race -count=1 -timeout=10m -run '^TestChaosSourceCache(GateMatrix|CollectionSemantics|InterruptResume|GenerationalSteadyState|CompatDriftOnResume|ReplayWithoutHitFailsCold|DriftedResumeRejectsRestoredReplay|DuplicateReplayCursorsParallel|UnsupportedShapesBlockReplaySeed)$$' ./pkg/sync .PHONY: chaos-full-check chaos-full-check: ## Run every deterministic chaos corpus under race detection. - BATON_TEST_NIGHTLY=1 go test -race -count=1 -timeout=30m -run '^TestChaosConnector' ./pkg/sync + BATON_TEST_NIGHTLY=1 go test -race -count=1 -timeout=30m -run '^TestChaos(Connector|SourceCache)' ./pkg/sync .PHONY: chaos-soak chaos-soak: ## Run extended seeded chaos connector fanout schedules. @@ -310,6 +311,53 @@ prodscale-crossover: ## Measure fold/overlay crossover at production scale. prodscale-topebble: ## Measure SQLite-to-Pebble conversion at production scale. BATON_PROD_SCALE_TOPEBBLE=1 go test -v -count=1 -timeout=180m -run TestProdScaleToPebbleCurve ./pkg/synccompactor +# Formal verification track (formal/). These targets have tool +# prerequisites this repo deliberately does not install: the P checker +# (`p` on PATH — https://p-org.github.io/P/) for the model sweeps, and a +# sibling engine checkout at ../occult (the host go.mod `replace` target) +# plus a Go 1.26 toolchain for the Occult suite. Each target checks its +# prerequisite and says what is missing rather than failing confusingly. +# +# The sweep targets REGENERATE the committed evidence summaries +# (formal/*/PCheckerOutput/*/summary.txt): a clean run reproduces them +# byte-for-byte apart from find-rate noise on RED cells, and a mismatch +# line or changed cell count is a calibration drift finding, not noise. +# Walker (55 cells) and graph (66 cells) each take on the order of half +# an hour at the default schedule budget; the bake-off (12 cells) about +# twenty minutes. +P_SCHEDULES ?= 10000 +OCCULT_TEST_TIMEOUT ?= 90m + +.PHONY: p-checker-guard +p-checker-guard: + @command -v p >/dev/null 2>&1 || { \ + echo "formal: the P checker ('p') is not on PATH — install it per https://p-org.github.io/P/ (no install target is provided)" >&2; \ + exit 2; \ + } + +.PHONY: formal-walker-sweep +formal-walker-sweep: p-checker-guard ## Compile and sweep the walker model (55 cells; needs P). + cd formal/walker && p compile -pp walker.pproj && tools/sweep.sh $(P_SCHEDULES) + +.PHONY: formal-graph-sweep +formal-graph-sweep: p-checker-guard ## Compile and sweep the graph model (66 cells; needs P). + cd formal/graph && p compile -pp graph.pproj && tools/sweep.sh $(P_SCHEDULES) + +.PHONY: formal-graph-bakeoff +formal-graph-bakeoff: p-checker-guard ## Run the 12-cell bake-off phase (needs P). + cd formal/graph && p compile -pp graph.pproj && tools/bakeoff.sh $(P_SCHEDULES) + +.PHONY: formal-occult-check +formal-occult-check: ## Run the Occult host suite (needs ../occult and Go 1.26). + @test -d ../occult || { \ + echo "formal-occult-check: sibling engine checkout not found at ../occult (the formal/occult/host go.mod 'replace' target); clone it beside this repo (no install target is provided)" >&2; \ + exit 2; \ + } + cd formal/occult/host && go test -timeout $(OCCULT_TEST_TIMEOUT) ./... + +.PHONY: formal-check +formal-check: formal-walker-sweep formal-graph-sweep formal-graph-bakeoff formal-occult-check ## Run every formal-track sweep and suite. + .PHONY: pkg/sdk/version.go pkg/sdk/version.go: echo $(VERSION) diff --git a/formal/README.md b/formal/README.md index 7d22acd42..1e69b09a7 100644 --- a/formal/README.md +++ b/formal/README.md @@ -70,6 +70,13 @@ p compile p check -tc -i 10000 ``` +The repo root Makefile wraps the standard runs — `make +formal-walker-sweep`, `make formal-graph-sweep`, `make +formal-graph-bakeoff` (override the budget with `P_SCHEDULES=`), `make +formal-occult-check` (needs the sibling `../occult` checkout and a Go +1.26 toolchain), and `make formal-check` for all of them. Each target +reports its missing prerequisite by name; none are installed for you. + ## Standing rules - Calibration before trust: the model earns authority by mechanically From a83e4b52881cbce1ef55fdef9c8387c9346a1df5 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Mon, 31 Aug 2026 16:12:32 -0600 Subject: [PATCH 05/12] Makefile: drop 6b-branch chaos patterns that leaked into the formal targets commit The formal PR adds only the formal-* targets; the chaos-check / chaos-full-check source-cache patterns belong to the 6b branch whose tests are not on main. Co-authored-by: Cursor --- Makefile | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Makefile b/Makefile index a215c8e22..5e3570392 100644 --- a/Makefile +++ b/Makefile @@ -272,11 +272,10 @@ errorfs-soak: ## Sweep whole-sync Pebble crash points using errorfs. chaos-check: ## Run bounded representative chaos checks under race detection. go test -race -count=1 ./internal/chaosconnector/... go test -race -count=1 -timeout=10m -run '^TestChaosConnector(LostResponseThenFilesystemFailureResumes|ResourcesAndEntitlementsFaultMatrix|ListGrantsFaultMatrix|ReservedBatonIDOwnershipIsRejected|MalformedKnownAnnotationFailsWithoutSealing|ClearedNextPageTokenSealsOnlyVisiblePrefix|CancellationTerminatesAndColdResumes|DataPolicyLifecycleCorpus|ExternalPrincipalResumeUsesCurrentExternalAnswer|SQLiteExternalPrincipalResumeDegradesWithoutFailure|ExternalPrincipalCleanupUsesOnePassPerKeyspace)$$' ./pkg/sync - go test -race -count=1 -timeout=10m -run '^TestChaosSourceCache(GateMatrix|CollectionSemantics|InterruptResume|GenerationalSteadyState|CompatDriftOnResume|ReplayWithoutHitFailsCold|DriftedResumeRejectsRestoredReplay|DuplicateReplayCursorsParallel|UnsupportedShapesBlockReplaySeed)$$' ./pkg/sync .PHONY: chaos-full-check chaos-full-check: ## Run every deterministic chaos corpus under race detection. - BATON_TEST_NIGHTLY=1 go test -race -count=1 -timeout=30m -run '^TestChaos(Connector|SourceCache)' ./pkg/sync + BATON_TEST_NIGHTLY=1 go test -race -count=1 -timeout=30m -run '^TestChaosConnector' ./pkg/sync .PHONY: chaos-soak chaos-soak: ## Run extended seeded chaos connector fanout schedules. From 3b589b134debee949c2493a97ca9c39efc240a7a Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Mon, 31 Aug 2026 16:48:35 -0600 Subject: [PATCH 06/12] formal: restore the bake-off alarm audit, drop a dead probe fixture MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit tools/bakeoff.sh lost sweep.sh's firing-monitor extraction in the round-1 split, so expected-RED cells were audited for counterexample presence only and would have recorded ok on a deadlock or liveness counterexample. The tag is restored (SEAL-WORLD added to both scripts — the G5d monitor was missing from sweep.sh's alternation), the bake-off summary regenerated with [EXEC-BOUND] / [SEAL-WORLD] tags at 12/12, and the calibration log now states the audit property. Also dropped the orphaned rogue fixture left in probeConstrainedSrc when the refusal control moved to probeBuiltinSrc. Co-authored-by: Cursor --- formal/graph/CALIBRATION.md | 9 +++++++-- formal/graph/PCheckerOutput/bakeoff/summary.txt | 12 ++++++------ formal/graph/tools/bakeoff.sh | 13 ++++++++++++- formal/graph/tools/sweep.sh | 6 +++++- formal/occult/host/constrained_params_probe_test.go | 3 --- 5 files changed, 30 insertions(+), 13 deletions(-) diff --git a/formal/graph/CALIBRATION.md b/formal/graph/CALIBRATION.md index 382c45cd9..0f88b3d94 100644 --- a/formal/graph/CALIBRATION.md +++ b/formal/graph/CALIBRATION.md @@ -404,8 +404,13 @@ blocks Axis-3 citation until dispositioned (GS-CO-005(d)). `PCheckerOutput/bakeoff/summary.txt`; reproduce with `tools/bakeoff.sh`, which carries exactly these 12 cells — they are deliberately NOT in `tools/sweep.sh`, so re-running the calibration -sweep cannot overwrite this phase's evidence and vice versa). All -four v1 controls GREEN +sweep cannot overwrite this phase's evidence and vice versa). Every +red records its FIRING MONITOR as an alarm tag, the same audit the +sweep applies: `[EXEC-BOUND]` on the two G6b probes, `[SEAL-WORLD]` +on the four reachable-world probes. The tag is what makes an +expected-RED cell auditable — counterexample presence alone matches +`expected=RED` even for a cell that redded on a deadlock instead of +its calibrated monitor. All four v1 controls GREEN (the zero-crash redo floor is bound 1 under BOTH variants — the count oracle measures crash-caused redo, not variant overhead); both G6b bound-1 probes RED on EXEC-BOUND (the mutation chassis's redo is diff --git a/formal/graph/PCheckerOutput/bakeoff/summary.txt b/formal/graph/PCheckerOutput/bakeoff/summary.txt index b9f445f78..21e491ad6 100644 --- a/formal/graph/PCheckerOutput/bakeoff/summary.txt +++ b/formal/graph/PCheckerOutput/bakeoff/summary.txt @@ -2,12 +2,12 @@ tcG6aE_Ctl expected=GREEN observed=GREEN ok tcG6aS_Ctl expected=GREEN observed=GREEN ok tcG6cE_Ctl expected=GREEN observed=GREEN ok tcG6cS_Ctl expected=GREEN observed=GREEN ok -tcG6bE_Redo expected=RED observed=RED ok -tcG6bS_Redo expected=RED observed=RED ok -tcG5dE_W1 expected=RED observed=RED ok -tcG5dS_W1 expected=RED observed=RED ok -tcG5dE_W2 expected=RED observed=RED ok -tcG5dS_W2 expected=RED observed=RED ok +tcG6bE_Redo expected=RED observed=RED ok [EXEC-BOUND] +tcG6bS_Redo expected=RED observed=RED ok [EXEC-BOUND] +tcG5dE_W1 expected=RED observed=RED ok [SEAL-WORLD] +tcG5dS_W1 expected=RED observed=RED ok [SEAL-WORLD] +tcG5dE_W2 expected=RED observed=RED ok [SEAL-WORLD] +tcG5dS_W2 expected=RED observed=RED ok [SEAL-WORLD] tcG5dE_W3 expected=GREEN observed=GREEN ok tcG5dS_W3 expected=GREEN observed=GREEN ok BAKEOFF-DONE cells=12 mismatches=0 diff --git a/formal/graph/tools/bakeoff.sh b/formal/graph/tools/bakeoff.sh index 8e37f1f4b..4b27e5b4a 100755 --- a/formal/graph/tools/bakeoff.sh +++ b/formal/graph/tools/bakeoff.sh @@ -44,7 +44,18 @@ for entry in $CELLS; do ce=$(ls "$OUT/$cell"/BugFinding/graph_[0-9]*_[0-9]*.txt 2>/dev/null | head -1) if [ -n "$ce" ]; then observed="RED"; else observed="GREEN"; fi if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi - line="$cell expected=$expected observed=$observed $mark" + # The alarm tag is what makes an expected-RED cell auditable: + # counterexample PRESENCE alone matches expected=RED even when the + # cell redded for a different reason than its calibrated monitor (P + # also emits a counterexample for deadlock and liveness), so the + # firing monitor name is extracted and recorded. Kept in sync with + # sweep.sh's alternation so a cell moved between the scripts keeps + # its tagging; SEAL-WORLD is the G5d bake-off monitor. + detail="" + if [ "$observed" = "RED" ]; then + detail=" [$(rg -o "(P-GEN|P-MARK|P-ADOPT|P1-[A-Z-]+[A-Z]|P2-[A-Z]+|P3'-[A-Z]+|P4-STUCK|P5-UNDER|P5-OVER|P6-[GES]|SEAL-EXPECT|SEAL-WORLD|REDO-PROBE|PURGE-PROBE|POISON-PROBE|DEAD-DISPATCH|PASS-BUDGET|EXEC-BOUND|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" + fi + line="$cell expected=$expected observed=$observed $mark$detail" echo "$line" | tee -a "$SUMMARY" done echo "BAKEOFF-DONE cells=$total mismatches=$mismatches" | tee -a "$SUMMARY" diff --git a/formal/graph/tools/sweep.sh b/formal/graph/tools/sweep.sh index a0c4e6142..c342bdc9b 100755 --- a/formal/graph/tools/sweep.sh +++ b/formal/graph/tools/sweep.sh @@ -100,7 +100,11 @@ for entry in $CELLS; do if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi detail="" if [ "$observed" = "RED" ]; then - detail=" [$(rg -o "(P-GEN|P-MARK|P-ADOPT|P1-[A-Z-]+[A-Z]|P2-[A-Z]+|P3'-[A-Z]+|P4-STUCK|P5-UNDER|P5-OVER|P6-[GES]|SEAL-EXPECT|REDO-PROBE|PURGE-PROBE|POISON-PROBE|DEAD-DISPATCH|PASS-BUDGET|EXEC-BOUND|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" + # SEAL-WORLD is currently a bake-off-only monitor (tools/bakeoff.sh), + # kept in the alternation so a G5d-shaped cell landing here is not + # silently untagged. Output-neutral for the frozen 66 cells: the + # hyphenated string appears only in that assert's message. + detail=" [$(rg -o "(P-GEN|P-MARK|P-ADOPT|P1-[A-Z-]+[A-Z]|P2-[A-Z]+|P3'-[A-Z]+|P4-STUCK|P5-UNDER|P5-OVER|P6-[GES]|SEAL-EXPECT|SEAL-WORLD|REDO-PROBE|PURGE-PROBE|POISON-PROBE|DEAD-DISPATCH|PASS-BUDGET|EXEC-BOUND|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" fi line="$cell expected=$expected observed=$observed $mark$detail" echo "$line" | tee -a "$SUMMARY" diff --git a/formal/occult/host/constrained_params_probe_test.go b/formal/occult/host/constrained_params_probe_test.go index 0c1c08220..f72e20729 100644 --- a/formal/occult/host/constrained_params_probe_test.go +++ b/formal/occult/host/constrained_params_probe_test.go @@ -57,7 +57,6 @@ syntax("standard"); ∃ ev_a; ∃ ev_b; -∃ s_rogue; ∃ tnil; ∃ tcons; @@ -81,8 +80,6 @@ probe_go(tcons(ev_b(s), r), ff) = "violation: b-before-a"; ∃ probe_green; probe_green = tcons(ev_a(s1), tcons(ev_b(s2), tnil)); -∃ probe_rogue; -probe_rogue = tcons(ev_a(s_rogue), tnil); ` // probePremiseSrc states the gate as an explicit rewrite premise From f4f39e2b081d2c1005d34640b5a3408105adc835 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Mon, 31 Aug 2026 17:57:38 -0600 Subject: [PATCH 07/12] formal: make the verdict scripts' exit status carry the verdict Round-3 review batch. The sweep/bake-off scripts previously ended on a tee pipeline, so a drifted run read as a green make; now they fail loudly: - nonzero exit on any mismatch - a counterexample-free nonzero p-check exit is CHECKER-ERROR, not GREEN ("no bug found" from a checker that died is not evidence) - an untagged red (firing monitor outside the alternation, or rg missing - now guarded) is a MISMATCH - the bake-off's declared alarms are ENFORCED, not just recorded, and the graph alternation is hoisted into tools/alarms.sh (one copy, sourced by both scripts) - tcG5dS_W2 pins --sch-feedbackpct=20: its find is seed-bimodal under uniform random (one full-10k seed explored 18 timelines and found nothing; five other seeds all found within ~500 schedules at a 0.23% buggy-schedule rate) - caught by the hardened gate's own first parity run and registered in CALIBRATION.md - refimpl: drop the write-only durable.checkpoint field (sibling of the already-removed hasMarker) Validated by a planted-violation harness (wrong alarm, unrecognized monitor, checker crash, drift verdicts, missing rg - each fails with the right summary line and exit status) and a full bake-off run through the final script: 12/12 match, exit 0, committed summary reproduced byte-for-byte. Refimpl build/vet and all four oracle tests green. Co-authored-by: Cursor --- Makefile | 8 +-- formal/graph/CALIBRATION.md | 24 ++++++++- formal/graph/tools/alarms.sh | 28 +++++++++++ formal/graph/tools/bakeoff.sh | 70 ++++++++++++++++++++------- formal/graph/tools/sweep.sh | 35 +++++++++++--- formal/occult/host/refimpl/refimpl.go | 11 +++-- formal/walker/tools/sweep.sh | 38 +++++++++++++-- 7 files changed, 177 insertions(+), 37 deletions(-) create mode 100644 formal/graph/tools/alarms.sh diff --git a/Makefile b/Makefile index 5e3570392..862ad3fa7 100644 --- a/Makefile +++ b/Makefile @@ -321,9 +321,11 @@ prodscale-topebble: ## Measure SQLite-to-Pebble conversion at production scale. # (formal/*/PCheckerOutput/*/summary.txt): a clean run reproduces them # byte-for-byte apart from find-rate noise on RED cells, and a mismatch # line or changed cell count is a calibration drift finding, not noise. -# Walker (55 cells) and graph (66 cells) each take on the order of half -# an hour at the default schedule budget; the bake-off (12 cells) about -# twenty minutes. +# The scripts' exit status carries that verdict — any mismatch (drifted +# cell, untagged red, wrong bake-off alarm, checker error) fails the +# target. Walker (55 cells) and graph (66 cells) each take on the order +# of half an hour at the default schedule budget; the bake-off (12 +# cells) about twenty minutes. P_SCHEDULES ?= 10000 OCCULT_TEST_TIMEOUT ?= 90m diff --git a/formal/graph/CALIBRATION.md b/formal/graph/CALIBRATION.md index 0f88b3d94..80aefa96b 100644 --- a/formal/graph/CALIBRATION.md +++ b/formal/graph/CALIBRATION.md @@ -400,7 +400,8 @@ blocks Axis-3 citation until dispositioned (GS-CO-005(d)). ### Bake-off results — 2026-08-30, 12/12 match declarations -10k schedules per cell, uniform random, one run (summary archived at +10k schedules per cell, uniform random except `tcG5dS_W2`, which +carries `--sch-feedbackpct=20` in the script (summary archived at `PCheckerOutput/bakeoff/summary.txt`; reproduce with `tools/bakeoff.sh`, which carries exactly these 12 cells — they are deliberately NOT in `tools/sweep.sh`, so re-running the calibration @@ -410,7 +411,13 @@ sweep applies: `[EXEC-BOUND]` on the two G6b probes, `[SEAL-WORLD]` on the four reachable-world probes. The tag is what makes an expected-RED cell auditable — counterexample presence alone matches `expected=RED` even for a cell that redded on a deadlock instead of -its calibrated monitor. All four v1 controls GREEN +its calibrated monitor — and in the bake-off it is ENFORCED, not just +recorded: each red cell declares its calibrated monitor in the script +and a red whose tag lacks it is a MISMATCH (sound here because every +bake-off red has exactly one pre-registered monitor; sweep cells can +legitimately red on more than one calibrated shape, so their tags +stay informational with CALIBRATION.md as the comparison surface). +All four v1 controls GREEN (the zero-crash redo floor is bound 1 under BOTH variants — the count oracle measures crash-caused redo, not variant overhead); both G6b bound-1 probes RED on EXEC-BOUND (the mutation chassis's redo is @@ -425,6 +432,19 @@ Axis-3 citation is unblocked. Where the two variants differ is HOW a world is reached (E purges C / S refuses C's dispatch on the W1 path), never WHICH worlds are sealable. +`tcG5dS_W2` STRATEGY PIN (2026-08-31): the cell's find is +seed-BIMODAL under uniform random — one full-10k seed explored 18 +timelines and found nothing while five other seeds (three uniform, +two feedback) all found within ~500 schedules at a 0.23% +buggy-schedule rate, a miss that is ~e^-23 improbable if schedules +were independent draws. Some seeds evidently cannot reach the target +at all, so the cell carries `--sch-feedbackpct=20` in `bakeoff.sh` — +the same remedy the sweep gives its narrow cells (`tcG2awWA_E`, +`tcG1d_P6G`) and the same lesson BAKEOFF.md's methodology note 4 +records: narrow-target kills must not rely on uniform random +schedules. The world's REACHABILITY is unaffected (found under both +strategies); only the gate's reliability needed the pin. + ## Pending - Nothing. The verdict document is `BAKEOFF.md` (assembled under GS-CO-005's registered decision rule). diff --git a/formal/graph/tools/alarms.sh b/formal/graph/tools/alarms.sh new file mode 100644 index 000000000..3702b3bee --- /dev/null +++ b/formal/graph/tools/alarms.sh @@ -0,0 +1,28 @@ +#!/usr/bin/env bash +# Shared alarm-tag extraction for the graph model's verdict scripts +# (sweep.sh and bakeoff.sh source this). ONE definition of the +# monitor-name alternation: when the two scripts each carried a copy, +# a monitor added to only one would silently emit an empty tag in the +# other's committed evidence, so there are no copies. SEAL-WORLD is +# asserted only by the bake-off's tcG5d* cells but stays in the shared +# alternation (output-neutral for the frozen 66 sweep cells; a +# G5d-shaped cell landing in the sweep is not silently untagged). +# +# The tag pipeline needs rg. Without this guard a missing rg is +# swallowed into an empty command substitution — the same empty tag a +# red cell with an unrecognized monitor produces — so sourcing this +# file fails loudly instead. +command -v rg >/dev/null 2>&1 || { + echo "graph tools: rg (ripgrep) is required for alarm-tag extraction and is not on PATH" >&2 + exit 2 +} + +MONITOR_ALTERNATION="P-GEN|P-MARK|P-ADOPT|P1-[A-Z-]+[A-Z]|P2-[A-Z]+|P3'-[A-Z]+|P4-STUCK|P5-UNDER|P5-OVER|P6-[GES]|SEAL-EXPECT|SEAL-WORLD|REDO-PROBE|PURGE-PROBE|POISON-PROBE|DEAD-DISPATCH|PASS-BUDGET|EXEC-BOUND|Deadlock detected|liveness" + +# alarm_tag — comma-joined sorted set of the +# firing monitor names found in the trace. Empty when nothing in the +# alternation matches; callers treat an empty tag on a RED cell as a +# MISMATCH (an untagged red is unauditable). +alarm_tag() { + rg -o "($MONITOR_ALTERNATION)" "$1" | sort -u | paste -sd, - +} diff --git a/formal/graph/tools/bakeoff.sh b/formal/graph/tools/bakeoff.sh index 4b27e5b4a..0e9a0cf5d 100755 --- a/formal/graph/tools/bakeoff.sh +++ b/formal/graph/tools/bakeoff.sh @@ -7,24 +7,36 @@ # # Usage: tools/bakeoff.sh [schedules] (run from formal/graph) set -u +. "$(dirname "$0")/alarms.sh" S="${1:-10000}" OUT="PCheckerOutput/bakeoff" SUMMARY="$OUT/summary.txt" mkdir -p "$OUT" : > "$SUMMARY" -# cell:expected (RED = counterexample expected, GREEN = none). +# cell:expected[:alarm[:strategy]] (RED = counterexample expected, +# GREEN = none). The third field is the cell's calibrated monitor and +# it is ENFORCED: counterexample presence alone matches expected=RED +# even for a cell that redded on a deadlock instead of its declared +# property, so a RED whose extracted tag does not contain the declared +# alarm is a MISMATCH. Enforcement is sound here because every +# bake-off red has exactly one pre-registered monitor (unlike sweep +# cells, which can legitimately red on more than one calibrated shape +# — see sweep.sh). The optional fourth field is an extra p-check +# strategy flag for cells whose target is too narrow for uniform +# random search to find reliably at the default budget — same +# mechanism as the sweep's third field. CELLS=" tcG6aE_Ctl:GREEN tcG6aS_Ctl:GREEN tcG6cE_Ctl:GREEN tcG6cS_Ctl:GREEN -tcG6bE_Redo:RED -tcG6bS_Redo:RED -tcG5dE_W1:RED -tcG5dS_W1:RED -tcG5dE_W2:RED -tcG5dS_W2:RED +tcG6bE_Redo:RED:EXEC-BOUND +tcG6bS_Redo:RED:EXEC-BOUND +tcG5dE_W1:RED:SEAL-WORLD +tcG5dS_W1:RED:SEAL-WORLD +tcG5dE_W2:RED:SEAL-WORLD +tcG5dS_W2:RED:SEAL-WORLD:--sch-feedbackpct=20 tcG5dE_W3:GREEN tcG5dS_W3:GREEN " @@ -35,27 +47,49 @@ for entry in $CELLS; do rest="${entry#*:}" cell="${entry%%:*}" expected="${rest%%:*}" + alarm="" strategy="" - case "$rest" in *:*) strategy="${rest#*:}";; esac + case "$rest" in *:*) + rest="${rest#*:}" + alarm="${rest%%:*}" + case "$rest" in *:*) strategy="${rest#*:}";; esac + ;; esac total=$((total + 1)) rm -rf "$OUT/$cell" # shellcheck disable=SC2086 p check -tc "$cell" -s "$S" ${strategy/=/ } -o "$OUT/$cell" > "$OUT/$cell.log" 2>&1 + pstatus=$? ce=$(ls "$OUT/$cell"/BugFinding/graph_[0-9]*_[0-9]*.txt 2>/dev/null | head -1) - if [ -n "$ce" ]; then observed="RED"; else observed="GREEN"; fi - if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi - # The alarm tag is what makes an expected-RED cell auditable: - # counterexample PRESENCE alone matches expected=RED even when the - # cell redded for a different reason than its calibrated monitor (P - # also emits a counterexample for deadlock and liveness), so the - # firing monitor name is extracted and recorded. Kept in sync with - # sweep.sh's alternation so a cell moved between the scripts keeps - # its tagging; SEAL-WORLD is the G5d bake-off monitor. + # Verdict precedence: a counterexample is RED even if the checker + # then exited nonzero (the find stands); a counterexample-free + # nonzero exit is CHECKER-ERROR, not GREEN — "no bug found" from a + # checker that died is not evidence of anything. + if [ -n "$ce" ]; then observed="RED" + elif [ "$pstatus" -ne 0 ]; then observed="CHECKER-ERROR" + else observed="GREEN"; fi + mark="ok" + [ "$observed" = "$expected" ] || mark="MISMATCH" detail="" if [ "$observed" = "RED" ]; then - detail=" [$(rg -o "(P-GEN|P-MARK|P-ADOPT|P1-[A-Z-]+[A-Z]|P2-[A-Z]+|P3'-[A-Z]+|P4-STUCK|P5-UNDER|P5-OVER|P6-[GES]|SEAL-EXPECT|SEAL-WORLD|REDO-PROBE|PURGE-PROBE|POISON-PROBE|DEAD-DISPATCH|PASS-BUDGET|EXEC-BOUND|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" + tag=$(alarm_tag "$ce") + # Empty tag = firing monitor outside the shared alternation + # (tools/alarms.sh): unauditable, so a mismatch even when RED was + # expected. Declared-alarm check is a substring match against the + # comma-joined tag set — sound while no monitor name is a prefix + # of another (EXEC-BOUND and SEAL-WORLD are not). + [ -n "$tag" ] || mark="MISMATCH" + if [ -n "$alarm" ]; then + case "$tag" in *"$alarm"*) ;; *) mark="MISMATCH";; esac + fi + detail=" [$tag]" + elif [ "$observed" = "CHECKER-ERROR" ]; then + detail=" (p exit $pstatus, see $OUT/$cell.log)" fi + [ "$mark" = "ok" ] || mismatches=$((mismatches + 1)) line="$cell expected=$expected observed=$observed $mark$detail" echo "$line" | tee -a "$SUMMARY" done echo "BAKEOFF-DONE cells=$total mismatches=$mismatches" | tee -a "$SUMMARY" +# The exit status carries the verdict (the Makefile's formal targets +# rely on it): a drifted run must not read as a green make. +[ "$mismatches" -eq 0 ] diff --git a/formal/graph/tools/sweep.sh b/formal/graph/tools/sweep.sh index c342bdc9b..5f83b48ab 100755 --- a/formal/graph/tools/sweep.sh +++ b/formal/graph/tools/sweep.sh @@ -5,6 +5,7 @@ # # Usage: tools/sweep.sh [schedules] (run from formal/graph) set -u +. "$(dirname "$0")/alarms.sh" S="${1:-10000}" OUT="PCheckerOutput/sweep" SUMMARY="$OUT/summary.txt" @@ -95,18 +96,38 @@ for entry in $CELLS; do rm -rf "$OUT/$cell" # shellcheck disable=SC2086 p check -tc "$cell" -s "$S" ${strategy/=/ } -o "$OUT/$cell" > "$OUT/$cell.log" 2>&1 + pstatus=$? ce=$(ls "$OUT/$cell"/BugFinding/graph_[0-9]*_[0-9]*.txt 2>/dev/null | head -1) - if [ -n "$ce" ]; then observed="RED"; else observed="GREEN"; fi - if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi + # Verdict precedence: a counterexample is RED even if the checker + # then exited nonzero (the find stands); a counterexample-free + # nonzero exit is CHECKER-ERROR, not GREEN — "no bug found" from a + # checker that died is not evidence of anything. + if [ -n "$ce" ]; then observed="RED" + elif [ "$pstatus" -ne 0 ]; then observed="CHECKER-ERROR" + else observed="GREEN"; fi + mark="ok" + [ "$observed" = "$expected" ] || mark="MISMATCH" detail="" if [ "$observed" = "RED" ]; then - # SEAL-WORLD is currently a bake-off-only monitor (tools/bakeoff.sh), - # kept in the alternation so a G5d-shaped cell landing here is not - # silently untagged. Output-neutral for the frozen 66 cells: the - # hyphenated string appears only in that assert's message. - detail=" [$(rg -o "(P-GEN|P-MARK|P-ADOPT|P1-[A-Z-]+[A-Z]|P2-[A-Z]+|P3'-[A-Z]+|P4-STUCK|P5-UNDER|P5-OVER|P6-[GES]|SEAL-EXPECT|SEAL-WORLD|REDO-PROBE|PURGE-PROBE|POISON-PROBE|DEAD-DISPATCH|PASS-BUDGET|EXEC-BOUND|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" + tag=$(alarm_tag "$ce") + # An empty tag means the firing monitor is outside the shared + # alternation (tools/alarms.sh) — an untagged red is unauditable, + # so it is a mismatch even when RED was expected. Per-cell alarm + # ENFORCEMENT is deliberately bake-off-only (see bakeoff.sh): + # sweep cells can legitimately red on more than one calibrated + # shape (e.g. the walker's tc3a_P1), so the sweep's comparison + # surface for WHICH monitor fired is CALIBRATION.md, not this + # script. + [ -n "$tag" ] || mark="MISMATCH" + detail=" [$tag]" + elif [ "$observed" = "CHECKER-ERROR" ]; then + detail=" (p exit $pstatus, see $OUT/$cell.log)" fi + [ "$mark" = "ok" ] || mismatches=$((mismatches + 1)) line="$cell expected=$expected observed=$observed $mark$detail" echo "$line" | tee -a "$SUMMARY" done echo "SWEEP-DONE cells=$total mismatches=$mismatches" | tee -a "$SUMMARY" +# The exit status carries the verdict (the Makefile's formal targets +# rely on it): a drifted sweep must not read as a green make. +[ "$mismatches" -eq 0 ] diff --git a/formal/occult/host/refimpl/refimpl.go b/formal/occult/host/refimpl/refimpl.go index f1efcca3f..662f85552 100644 --- a/formal/occult/host/refimpl/refimpl.go +++ b/formal/occult/host/refimpl/refimpl.go @@ -114,11 +114,15 @@ type Result struct { const scope = "s1" -// durable is the store state that survives a crash. +// durable is the store state that survives a crash. The checkpoint +// watermark is deliberately NOT part of it: both crash scenarios here +// crash before the (single) checkpoint, so resume logic never has a +// watermark to consult — legacy resumes off partition contents, the +// demand-graph path re-consults unconditionally. The checkpoint exists +// in this implementation only as its trace event. type durable struct { partition map[string]string - markerBase int // the replay unit's attested base epoch - checkpoint bool // scope watermark: scope completed at Head + markerBase int // the replay unit's attested base epoch } // Run executes the sync to seal, crashing and resuming if configured. @@ -185,7 +189,6 @@ func runAttempt(cfg Config, st *durable, attempt int) (trace []Event, sealed boo } emit("publish", scope) - st.checkpoint = true emit("checkpoint", "") emit("seal", "") return trace, true diff --git a/formal/walker/tools/sweep.sh b/formal/walker/tools/sweep.sh index 802c8a524..160a04709 100755 --- a/formal/walker/tools/sweep.sh +++ b/formal/walker/tools/sweep.sh @@ -6,6 +6,15 @@ # # Usage: tools/sweep.sh [schedules] (run from formal/walker) set -u +# The alarm-tag pipeline needs rg; without this guard a missing rg is +# swallowed into an empty tag, indistinguishable from an unrecognized +# monitor. (The graph scripts share tools/alarms.sh; this alternation +# is walker-specific and single-consumer, so it stays inline.) +command -v rg >/dev/null 2>&1 || { + echo "walker tools: rg (ripgrep) is required for alarm-tag extraction and is not on PATH" >&2 + exit 2 +} +MONITOR_ALTERNATION="P[0-9][0-9A-Z'-]*[A-Z]|SEAL-EXPECT|C1-PROBE|P4-STUCK|Deadlock detected|liveness" S="${1:-10000}" OUT="PCheckerOutput/sweep" SUMMARY="$OUT/summary.txt" @@ -79,14 +88,37 @@ for entry in $CELLS; do total=$((total + 1)) rm -rf "$OUT/$cell" p check -tc "$cell" -s "$S" -o "$OUT/$cell" > "$OUT/$cell.log" 2>&1 + pstatus=$? ce=$(ls "$OUT/$cell"/BugFinding/walker_[0-9]*_[0-9]*.txt 2>/dev/null | head -1) - if [ -n "$ce" ]; then observed="RED"; else observed="GREEN"; fi - if [ "$observed" = "$expected" ]; then mark="ok"; else mark="MISMATCH"; mismatches=$((mismatches + 1)); fi + # Verdict precedence: a counterexample is RED even if the checker + # then exited nonzero (the find stands); a counterexample-free + # nonzero exit is CHECKER-ERROR, not GREEN — "no bug found" from a + # checker that died is not evidence of anything. + if [ -n "$ce" ]; then observed="RED" + elif [ "$pstatus" -ne 0 ]; then observed="CHECKER-ERROR" + else observed="GREEN"; fi + mark="ok" + [ "$observed" = "$expected" ] || mark="MISMATCH" detail="" if [ "$observed" = "RED" ]; then - detail=" [$(rg -o "(P[0-9][0-9A-Z'-]*[A-Z]|SEAL-EXPECT|C1-PROBE|P4-STUCK|Deadlock detected|liveness)" "$ce" 2>/dev/null | sort -u | paste -sd, -)]" + tag=$(rg -o "($MONITOR_ALTERNATION)" "$ce" | sort -u | paste -sd, -) + # An empty tag means the firing monitor is outside the alternation + # above — an untagged red is unauditable, so it is a mismatch even + # when RED was expected. Per-cell alarm enforcement stays with the + # graph bake-off (bakeoff.sh): walker sweep cells can legitimately + # red on more than one calibrated shape (tc3a_P1's two P1 clauses), + # so the comparison surface for WHICH monitor fired is + # CALIBRATION.md, not this script. + [ -n "$tag" ] || mark="MISMATCH" + detail=" [$tag]" + elif [ "$observed" = "CHECKER-ERROR" ]; then + detail=" (p exit $pstatus, see $OUT/$cell.log)" fi + [ "$mark" = "ok" ] || mismatches=$((mismatches + 1)) line="$cell expected=$expected observed=$observed $mark$detail" echo "$line" | tee -a "$SUMMARY" done echo "SWEEP-DONE cells=$total mismatches=$mismatches" | tee -a "$SUMMARY" +# The exit status carries the verdict (the Makefile's formal targets +# rely on it): a drifted sweep must not read as a green make. +[ "$mismatches" -eq 0 ] From cf808a602d4ad3ce72dd90c075be3ce5065208b3 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Tue, 1 Sep 2026 09:42:32 -0600 Subject: [PATCH 08/12] formal: round-4 review batch + full-pass validation Review items: - bakeoff.sh grammar guard: the fields are positional and the alarm is only consulted on the RED branch, so a strategy flag written in the alarm slot (cell:GREEN:--flag) was dropped SILENTLY - the cell ran without its intended search and still reported ok. Now rejected at parse time with the strategy-only form (cell:expected::--flag) in the message; validated with a planted scratch run (exit 2). - sweep headers now state the exit-status division of labor: p check's exit gates only the GREEN side (absence of a find from a checker that died proves nothing); a found counterexample stands regardless. - TRACE_BRIDGE Mapping 1: the graph overlay unit also announces upserts and tombstones, and its G8b composeDead INJECT branch announces the copy with NO clear at all - by design, that missing clear IS the tcG8bMut_P1 kill. Stated as the one exception so a hand-renderer cannot mask the injected red by supplying a clear the model never announced (review comment from the r3899 wave). - Makefile formal comment untangled: tag differences on multi-shape RED cells are exit-0 noise; a missed find fails the gate by design. Full-pass validation, all through the hardened scripts: - walker sweep 55/55, exit 0, summary byte-identical - graph sweep 66/66, exit 0, summary byte-identical - bake-off 12/12, exit 0, summary byte-identical (prior run) - Occult host suite green against the engine's ground-eval-perf branch (6785def4): full suite in ~32 min wall vs 75+ before - verdict-preserving across the laws, MPST, 140-cell policy matrix, real-trace fixtures (both standing red pins intact), and refimpl. Also: cell lists cross-checked against committed evidence (55/66/12 exact), both alternations verified to cover their monitors' full assert vocabularies, no stale counts or dead refs. Co-authored-by: Cursor --- Makefile | 21 +++++++++++++-------- formal/graph/tools/bakeoff.sh | 15 +++++++++++++-- formal/graph/tools/sweep.sh | 5 ++++- formal/occult/TRACE_BRIDGE.md | 25 ++++++++++++++++--------- formal/walker/tools/sweep.sh | 6 +++++- 5 files changed, 51 insertions(+), 21 deletions(-) diff --git a/Makefile b/Makefile index 862ad3fa7..c26edddca 100644 --- a/Makefile +++ b/Makefile @@ -318,14 +318,19 @@ prodscale-topebble: ## Measure SQLite-to-Pebble conversion at production scale. # prerequisite and says what is missing rather than failing confusingly. # # The sweep targets REGENERATE the committed evidence summaries -# (formal/*/PCheckerOutput/*/summary.txt): a clean run reproduces them -# byte-for-byte apart from find-rate noise on RED cells, and a mismatch -# line or changed cell count is a calibration drift finding, not noise. -# The scripts' exit status carries that verdict — any mismatch (drifted -# cell, untagged red, wrong bake-off alarm, checker error) fails the -# target. Walker (55 cells) and graph (66 cells) each take on the order -# of half an hour at the default schedule budget; the bake-off (12 -# cells) about twenty minutes. +# (formal/*/PCheckerOutput/*/summary.txt): a clean run reproduces every +# cell's verdict line, and the scripts' exit status carries that +# verdict — any mismatch (drifted cell, untagged red, wrong bake-off +# alarm, checker error) fails the target. Two kinds of run-to-run noise +# are possible and treated differently: an alarm-tag difference on a +# multi-shape RED cell (e.g. the walker's tc3a_P1 has two calibrated P1 +# shapes) diffs the summary but still exits 0, while a RED cell that +# MISSES its find fails the gate by design — that has happened once, +# from seed-bimodal search on a narrow target, and the remedy is a +# per-cell strategy pin (see the tcG5dS_W2 note in graph CALIBRATION). +# Walker (55 cells) and graph (66 cells) each take on the order of half +# an hour at the default schedule budget; the bake-off (12 cells) about +# twenty minutes. P_SCHEDULES ?= 10000 OCCULT_TEST_TIMEOUT ?= 90m diff --git a/formal/graph/tools/bakeoff.sh b/formal/graph/tools/bakeoff.sh index 0e9a0cf5d..f820c9041 100755 --- a/formal/graph/tools/bakeoff.sh +++ b/formal/graph/tools/bakeoff.sh @@ -54,6 +54,16 @@ for entry in $CELLS; do alarm="${rest%%:*}" case "$rest" in *:*) strategy="${rest#*:}";; esac ;; esac + # Grammar guard: the fields are positional and the alarm is only + # consulted on the RED branch, so a strategy flag written in the + # alarm slot (cell:GREEN:--flag) would be dropped SILENTLY — the + # cell would run without its intended search and still report ok. + # A strategy with no alarm takes an explicit empty third field + # (cell:expected::--flag). + case "$alarm" in --*) + echo "bakeoff.sh: $cell: third field must be the calibrated alarm, not '$alarm' — grammar is cell:expected[:alarm[:strategy]]; for strategy-only write $cell:$expected::$alarm" >&2 + exit 2 + ;; esac total=$((total + 1)) rm -rf "$OUT/$cell" # shellcheck disable=SC2086 @@ -75,8 +85,9 @@ for entry in $CELLS; do # Empty tag = firing monitor outside the shared alternation # (tools/alarms.sh): unauditable, so a mismatch even when RED was # expected. Declared-alarm check is a substring match against the - # comma-joined tag set — sound while no monitor name is a prefix - # of another (EXEC-BOUND and SEAL-WORLD are not). + # comma-joined tag set — sound while no declared alarm is a + # substring of a different monitor's name (EXEC-BOUND and + # SEAL-WORLD are not). [ -n "$tag" ] || mark="MISMATCH" if [ -n "$alarm" ]; then case "$tag" in *"$alarm"*) ;; *) mark="MISMATCH";; esac diff --git a/formal/graph/tools/sweep.sh b/formal/graph/tools/sweep.sh index 5f83b48ab..3de8c884a 100755 --- a/formal/graph/tools/sweep.sh +++ b/formal/graph/tools/sweep.sh @@ -1,7 +1,10 @@ #!/usr/bin/env bash # Graph-model cell regression sweep (walker tools/sweep.sh parity). # Verdicts are audited by counterexample trace-file presence, not the -# "Found N bugs" tail. +# "Found N bugs" tail; p check's exit status gates only the GREEN side +# (a counterexample-free nonzero exit is CHECKER-ERROR — absence of a +# find from a checker that died proves nothing — while a found +# counterexample stands regardless of exit status). # # Usage: tools/sweep.sh [schedules] (run from formal/graph) set -u diff --git a/formal/occult/TRACE_BRIDGE.md b/formal/occult/TRACE_BRIDGE.md index 3508aa23c..505e66664 100644 --- a/formal/occult/TRACE_BRIDGE.md +++ b/formal/occult/TRACE_BRIDGE.md @@ -98,15 +98,22 @@ Session events map to the session keyspace (`ev_swrite`), never to The atomic units expand to their ANNOUNCE order, which differs by model: the walker's `eReplayUnit`/`eOverlayUnit` announce clear, copy -(, upserts, tombstones), publish; the graph's -`eGReplayUnit`/`eGOverlayUnit` announce the marker put FIRST (the -P-MARK convention — see `graph/PSrc/Store.p`'s unit handlers), then -clear, copy, publish. Marker puts have no canonical event (generation -stamps are the tracked pending extension), so a rendered unit -contributes clear, copy, publish either way. The policies check the -leg ordering the units guarantee by construction; running unit-built -traces through the oracle is a consistency check of that guarantee, -not new information. Crash scenarios cut the list at the crash point: +(, upserts, tombstones), publish; the graph's `eGReplayUnit` announces +the marker put FIRST (the P-MARK convention — see +`graph/PSrc/Store.p`'s unit handlers), then clear, copy, publish; and +the graph's `eGOverlayUnit` announces marker, clear, copy, upserts, +tombstones, publish. Marker puts have no canonical event (generation +stamps are the tracked pending extension). ONE deliberate exception to +"every unit contributes a clear": under the G8b `composeDead` INJECT +(`Store.p`'s overlay handler, the `tcG8bMut_P1` kill), the overlay +unit composes onto existing debris and announces the copy with NO +clear at all — that missing clear IS the kill, so a hand-renderer +following this table must not supply a clear the model never +announced, or the injected counterexample's clear-before-write red is +masked into a green. The policies check the leg ordering the honest +units guarantee by construction; running unit-built traces through +the oracle is a consistency check of that guarantee, not new +information. Crash scenarios cut the list at the crash point: a cut trace must still satisfy the prefix-closed policies (1–3), while the seal-anchored policies (4–5) are vacuous without `ev_seal` — exactly the sync-scoped-freshness stance the models take. diff --git a/formal/walker/tools/sweep.sh b/formal/walker/tools/sweep.sh index 160a04709..9a3bf4665 100755 --- a/formal/walker/tools/sweep.sh +++ b/formal/walker/tools/sweep.sh @@ -2,7 +2,11 @@ # Full-cell regression sweep. Verdicts are audited by counterexample # trace-file presence (NOT the "Found N bugs" tail — see the NOTE in # CALIBRATION.md: the strategy portfolio's last block can report 0 -# bugs after an earlier block found one). +# bugs after an earlier block found one). p check's exit status gates +# only the GREEN side (a counterexample-free nonzero exit is +# CHECKER-ERROR — absence of a find from a checker that died proves +# nothing — while a found counterexample stands regardless of exit +# status). # # Usage: tools/sweep.sh [schedules] (run from formal/walker) set -u From 1cac907b64e7ba4ed7b94ca55e8969e8da526e07 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Tue, 1 Sep 2026 10:09:46 -0600 Subject: [PATCH 09/12] formal: complete the walker run log's missing scenario-4 section MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A PR review comment on the sweep's cell list was stale on all three of its claims (it predates the trace-archive purge, the probe-cell row, and the rewritten archival contract), but re-running the cell-vs-row audit it implied found the real gap next door: scenario 4 (duplicate replay carriers, MODEL_SPEC §9 case 4) has been in every sweep since the v11 freeze yet never had a section in CALIBRATION.md. Added with the frozen verdicts; no cell or expectation changed. The graph log audits clean under the same check (its G3/G4/G6-G9 families are deliberately collective-prose sections). Co-authored-by: Cursor --- formal/walker/CALIBRATION.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/formal/walker/CALIBRATION.md b/formal/walker/CALIBRATION.md index dcfd4b5ca..76c49770d 100644 --- a/formal/walker/CALIBRATION.md +++ b/formal/walker/CALIBRATION.md @@ -114,6 +114,26 @@ validators): | tc3bBindingOn_All | same premise, binding ON — the CO-6b-004 kill | P1+P2+P3′ | GREEN | GREEN — binding gate compares hit V_A to base V_B, fails LOUD-COLD (behavior, not assert); scope seals empty in premise schedules, no wrong data | 10000 schedules | | tc3atomic_All | v11: same stop+swap premise under V-ATOMIC — the `annotationBinding` de-scope's subsumption witness | P1+P2+P3′ | GREEN | GREEN — no carrier and no annotation exist; either the unit committed (marker in the CURRENT artifact suppresses attempt 2; seal is the unit's coherent contents) or attempt 2 re-consults the actually-current swapped base (V1 fails validation vs e2 → fetch-fresh). The 3A rebind hole is structurally closed: no restored hit authorizes replay | 20000 schedules | +## Scenario 4 — duplicate replay carriers (MODEL_SPEC §9 case 4) + +(Section added post-freeze: the four cells have been in every sweep +since the v11 freeze — see `traces/freeze-sweep-v11-summary.txt` — +but this log never carried their section; the run log is completed +here with the frozen verdicts, no cell or expectation changed.) + +Two carriers with byte-distinct page tokens (distinct aids) encoding +the same (scope, verdict); no interruption, no mutation; 2 syncs. The +dedup obligation is split across two shipped guards — `oncePerScope` +(the replayed-set mark) and `scopeLocks` (serialization) — and the +cells kill each guard separately: + +| cell | config | property | expected | observed | budget | +|---|---|---|---|---|---| +| tc4shipped_All | `oncePerScope` + `scopeLocks` ON (shipped) | P1+P2+P3′ | GREEN | GREEN — the second carrier's copy is deduped under the lock (grant carries the replayed status; the mark commits at release); its B5-legal copy-skipped round folds as a no-op re-publish | 10000 schedules | +| tc4noOnce_P1 | `oncePerScope` OFF, locks ON | P1 | RED | RED: `P1-LEGALITY` — both copies commit; the lock serializes but does not dedup | first find | +| tc4noLocks_P1 | `oncePerScope` ON, locks OFF | P1 | RED | RED: `P1-LEGALITY` — check-then-mark TOCTOU: both carriers read the replayed set before either transition commits the mark | first find | +| tc4atomic_All | V-ATOMIC re-run (v11 scope) | P1+P2+P3′ | GREEN | GREEN — carriers do not exist under the variant (replay is inline at the consult); the duplicate-carrier premise is structurally unreachable | 10000 schedules | + ## Scenario 5 — warm-drift (both produce triggers + the crash window) Upstream never moves (drift is config-side). Sync 1 seeds A = rows(e1) From 0591df932da40df2c6f1d0918dfca6dbe5011537 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Tue, 1 Sep 2026 10:55:41 -0600 Subject: [PATCH 10/12] formal: close the residual grammar-guard gaps in the verdict scripts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review follow-up on the round-4 guard: (1) bakeoff.sh's alarm-slot guard matched only --* so a single-dash flag still fell through and was silently dropped on a GREEN cell — the exact failure the guard exists to stop; alarm names never begin with a dash, so -* is safe. (2) sweep.sh's mirror field (third field = strategy) had no shape check, so an entry pasted in from bakeoff's 4-field grammar handed p check an alarm name as a bogus positional argument; it now fails loudly at parse time with the grammar named. Both guards exercised via stub-checker runs: bad entries exit 2 before any checker call, good entries (real flag; empty-alarm form) still reach GREEN. Also answered the standing Makefile evidence note: the 2026-09-01 full pass re-ran every cell through the gated scripts and reproduced all committed summaries byte-identically, which is why no post-gate summary commit exists. Co-authored-by: Cursor --- Makefile | 7 ++++++- formal/graph/tools/bakeoff.sh | 2 +- formal/graph/tools/sweep.sh | 9 +++++++++ 3 files changed, 16 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index c26edddca..b88362926 100644 --- a/Makefile +++ b/Makefile @@ -321,7 +321,12 @@ prodscale-topebble: ## Measure SQLite-to-Pebble conversion at production scale. # (formal/*/PCheckerOutput/*/summary.txt): a clean run reproduces every # cell's verdict line, and the scripts' exit status carries that # verdict — any mismatch (drifted cell, untagged red, wrong bake-off -# alarm, checker error) fails the target. Two kinds of run-to-run noise +# alarm, checker error) fails the target. The reproduction claim was +# validated AFTER the exit-status gate landed: the 2026-09-01 full +# pass re-ran every cell through the gated scripts and reproduced all +# three committed summaries byte-identically (which is also why the +# summaries carry no post-gate commit — identical bytes leave nothing +# to commit). Two kinds of run-to-run noise # are possible and treated differently: an alarm-tag difference on a # multi-shape RED cell (e.g. the walker's tc3a_P1 has two calibrated P1 # shapes) diffs the summary but still exits 0, while a RED cell that diff --git a/formal/graph/tools/bakeoff.sh b/formal/graph/tools/bakeoff.sh index f820c9041..e6d43ef4d 100755 --- a/formal/graph/tools/bakeoff.sh +++ b/formal/graph/tools/bakeoff.sh @@ -60,7 +60,7 @@ for entry in $CELLS; do # cell would run without its intended search and still report ok. # A strategy with no alarm takes an explicit empty third field # (cell:expected::--flag). - case "$alarm" in --*) + case "$alarm" in -*) echo "bakeoff.sh: $cell: third field must be the calibrated alarm, not '$alarm' — grammar is cell:expected[:alarm[:strategy]]; for strategy-only write $cell:$expected::$alarm" >&2 exit 2 ;; esac diff --git a/formal/graph/tools/sweep.sh b/formal/graph/tools/sweep.sh index 3de8c884a..edbf9e8e5 100755 --- a/formal/graph/tools/sweep.sh +++ b/formal/graph/tools/sweep.sh @@ -95,6 +95,15 @@ for entry in $CELLS; do expected="${rest%%:*}" strategy="" case "$rest" in *:*) strategy="${rest#*:}";; esac + # Grammar guard, symmetric to bakeoff.sh's: this script's third field + # is a p-check strategy flag, but bakeoff.sh's is the calibrated + # alarm — an entry pasted across the two grammars would hand p check + # an alarm name as a bogus positional argument. Fail loudly at parse + # time instead of with a confusing checker error mid-sweep. + if [ -n "$strategy" ]; then case "$strategy" in -*) ;; *) + echo "sweep.sh: $cell: third field must be a p-check strategy flag, not '$strategy' — grammar is cell:expected[:strategy] (the alarm-carrying 4-field grammar belongs to bakeoff.sh)" >&2 + exit 2 + ;; esac; fi total=$((total + 1)) rm -rf "$OUT/$cell" # shellcheck disable=SC2086 From a64c30578cbcce490b8b1ab95323d6d51d55b71c Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Tue, 1 Sep 2026 11:51:55 -0600 Subject: [PATCH 11/12] formal: witness P8's over-deletion clause, guard LoadExpressions, register unwitnessed-clause inventory MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round-5 review found the first substantive gaps in several waves, all three verified real. (1) tc8overDelete_P8: P8-EXT-MISSING had no kill — the over-deletion direction of the external-principal seal clause was asserted, not calibrated (P8's other two clauses and the P6-C pattern both witness bidirectionally). The kill models a LATE stale-sweep whose predicate mistakes a live principal for stale; placement is itself a model fact: the engine-ordered early pass (delete-stale before copy) is structurally self-healing for over-deletion because the page-1 copy rewrites every listed id. Sweep regenerated: 56 cells, 0 mismatches. (2) pipeline_test.go discarded LoadExpressions' error — a silent failure there would turn every negative control vacuous (an empty e-graph refuses every equivalence, which is what the controls assert); now t.Fatalf like every other engine call, equivalence suites re-run green. (3) The remaining asserted-but-unwitnessed alarm strings (walker 3, graph 8) are inventoried in REPORT.md's standing limits and the graph CALIBRATION so the green matrices are not over-read; the graph eight are walker-inherited oracles whose graph-side implementations are calibrated only by review. Co-authored-by: Cursor --- Makefile | 4 +-- formal/REPORT.md | 25 ++++++++++++++++- formal/graph/CALIBRATION.md | 13 +++++++++ formal/occult/host/pipeline_test.go | 11 ++++++-- formal/walker/CALIBRATION.md | 16 +++++++---- .../walker/PCheckerOutput/sweep/summary.txt | 5 ++-- formal/walker/PSrc/Env.p | 2 +- formal/walker/PSrc/Events.p | 2 +- formal/walker/PSrc/Store.p | 25 ++++++++++++++++- formal/walker/PSrc/Types.p | 13 +++++++-- formal/walker/PTst/Scenario8.p | 28 +++++++++++++++++-- formal/walker/tools/sweep.sh | 1 + 12 files changed, 125 insertions(+), 20 deletions(-) diff --git a/Makefile b/Makefile index b88362926..78c0d8d53 100644 --- a/Makefile +++ b/Makefile @@ -333,7 +333,7 @@ prodscale-topebble: ## Measure SQLite-to-Pebble conversion at production scale. # MISSES its find fails the gate by design — that has happened once, # from seed-bimodal search on a narrow target, and the remedy is a # per-cell strategy pin (see the tcG5dS_W2 note in graph CALIBRATION). -# Walker (55 cells) and graph (66 cells) each take on the order of half +# Walker (56 cells) and graph (66 cells) each take on the order of half # an hour at the default schedule budget; the bake-off (12 cells) about # twenty minutes. P_SCHEDULES ?= 10000 @@ -347,7 +347,7 @@ p-checker-guard: } .PHONY: formal-walker-sweep -formal-walker-sweep: p-checker-guard ## Compile and sweep the walker model (55 cells; needs P). +formal-walker-sweep: p-checker-guard ## Compile and sweep the walker model (56 cells; needs P). cd formal/walker && p compile -pp walker.pproj && tools/sweep.sh $(P_SCHEDULES) .PHONY: formal-graph-sweep diff --git a/formal/REPORT.md b/formal/REPORT.md index 8f15616fa..10c8780f3 100644 --- a/formal/REPORT.md +++ b/formal/REPORT.md @@ -33,7 +33,7 @@ resume behavior along the way. MS-CO-001) and the `walker/` P project. Authority is earned by rediscovery: with mitigations toggled off, the checker finds the known bugs; with the shipped/staged fixes toggled on, the same cells -go green. The current sweep is 55 cells, 0 mismatches, 10k schedules +go green. The current sweep is 56 cells, 0 mismatches, 10k schedules per cell (`walker/CALIBRATION.md`). Reproduced reds include: the phantom union in content, staleness, and @@ -270,6 +270,29 @@ counts at small scope, not throughput. The models arbitrate designs, not Go code; the trace bridge is the standing instrument that must stay current as the design becomes an implementation. +**Asserted-but-unwitnessed monitor clauses.** By this track's own +doctrine, a monitor clause no red cell fires is indistinguishable +from dead code, and the greens say nothing about it. The frozen +matrices leave these alarm strings unwitnessed; a reader must not +credit the green cells with covering them: + +- Walker (3 of its alarms): `P1-ATTEST-EMPTY`, `P1-ATTEST-PUBLISH`, + `P2-CONSULT`. Each is a narrower sibling of a witnessed clause on + the same monitor (`P1-ATTEST-SEAL`, `P1-CONTENT`, and + `P2-STALENESS` all have red cells); no cell targets these + specific legs. (`P8-EXT-MISSING`, formerly on this list, is now + witnessed by tc8overDelete_P8.) +- Graph (8 of its 25 alarms): `P1-CONTENT`, `P1-ATTEST-PUBLISH`, + `P1-ATTEST-SEAL`, `P1-ATTEST-EMPTY`, `P2-CONSULT`, + `P2-STALENESS`, `P3'-COHERENCE`, `PASS-BUDGET`. These are the + walker-inherited content/attestation/staleness oracles restated + over the graph store; the graph matrix's kills target the graph's + OWN mechanisms (generations, markers, adoption, sweep, counts — + all witnessed). The walker leg witnesses the same property + STATEMENTS with 9+ reds, but against the walker's checking code, + not the graph's — the graph implementations of these clauses are + calibrated only by review. + ## What's next 1. **The variant-S RFC and production implementation** in diff --git a/formal/graph/CALIBRATION.md b/formal/graph/CALIBRATION.md index 80aefa96b..aba9090ef 100644 --- a/formal/graph/CALIBRATION.md +++ b/formal/graph/CALIBRATION.md @@ -373,6 +373,19 @@ leg is clean. Three cells carry the pinned `--sch-feedbackpct=20` strategy (tcG1d_P6G, tcG2awWA_E, tcG8dMut_PMARK — deep-crash-window reach, G1D-REACH/G8D-CAL). The graph model is CALIBRATED and FROZEN. +COVERAGE LIMIT of the frozen matrix (registered post-freeze; no cell +or expectation changed): eight of Monitors.p's 25 alarm strings fire +in no red cell — P1-CONTENT, P1-ATTEST-PUBLISH, P1-ATTEST-SEAL, +P1-ATTEST-EMPTY, P2-CONSULT, P2-STALENESS, P3'-COHERENCE, +PASS-BUDGET. They are the walker-inherited content/attestation/ +staleness oracles restated over the graph store; the matrix's kills +deliberately target the graph's OWN mechanisms, and the walker leg +witnesses the same property statements with its own reds — but +against the walker's checking code. By this log's own doctrine those +eight clauses are asserted, not calibrated, in THIS model: a +green matrix says nothing about them. Inventory mirrored in +REPORT.md's standing limits so the 66-cell green is not over-read. + ## Bake-off phase — declarations (GS-CO-005, registered BEFORE run) The protocol, the restated decision rule, and the provenance repair diff --git a/formal/occult/host/pipeline_test.go b/formal/occult/host/pipeline_test.go index bd8ae9fe1..6dc13ae82 100644 --- a/formal/occult/host/pipeline_test.go +++ b/formal/occult/host/pipeline_test.go @@ -90,10 +90,17 @@ func equivalent(t *testing.T, requires []string, locals []localModule, lhs, rhs lhsQuery := findQueryNode(interp, lhsRoot) rhsQuery := findQueryNode(interp, rhsRoot) - interp.Solver.LoadExpressions(ctx, interp.Graph, []solve.Expr{ + // A swallowed error here is worse than a flake: the positives would + // fail loudly, but the negative controls assert REFUSAL, and an + // e-graph with no loaded expressions refuses every equivalence — + // they would all pass vacuously. (This module is outside root + // `make lint`, so errcheck does not cover it.) + if err := interp.Solver.LoadExpressions(ctx, interp.Graph, []solve.Expr{ {RootNodeID: lhsQuery}, {RootNodeID: rhsQuery}, - }) + }); err != nil { + t.Fatalf("LoadExpressions: %v", err) + } for _, root := range allRoots { if err := interp.BridgeModulePropertyAccess(ctx, root); err != nil { t.Fatalf("BridgeModulePropertyAccess root %d: %v", root, err) diff --git a/formal/walker/CALIBRATION.md b/formal/walker/CALIBRATION.md index 76c49770d..2cb0a08a9 100644 --- a/formal/walker/CALIBRATION.md +++ b/formal/walker/CALIBRATION.md @@ -1,10 +1,10 @@ # Walker calibration — run log -Status: COMPLETE. CURRENT GATE: the 55-cell full-matrix sweep, 0 +Status: COMPLETE. CURRENT GATE: the 56-cell full-matrix sweep, 0 mismatches, every red on its calibrated alarm (`tools/sweep.sh`, 10k schedules per cell; the run of record is `PCheckerOutput/sweep/summary.txt`, ending -`SWEEP-DONE cells=55 mismatches=0`). Scenarios 1, 2 (including the +`SWEEP-DONE cells=56 mismatches=0`). Scenarios 1, 2 (including the P6-C session-checkpoint-consistency tranche, decision 25 — the CO-6b-009 root cause made executable), 3, 4, 5 (both triggers + crash window + C1 probe), 6 (both flavors + the round-7 third-placement @@ -25,8 +25,9 @@ summaries archived under `traces/`): the 46-cell v11 freeze sweep (`traces/freeze-sweep-v11-summary.txt`; the pre-v11 44-cell sweep was also clean, isolating the P4 merge from the v11 monitor change), the 47-cell post-MS-CO-001 sweep -(`traces/msco001-sweep-summary.txt`), then +3 P6-C cells (50) and -+5 scenario-8 cells (the current 55). +(`traces/msco001-sweep-summary.txt`), then +3 P6-C cells (50), ++5 scenario-8 cells (55), and the tc8overDelete_P8 over-deletion +kill (the current 56). Toolchain: P 3.1.0 (`p compile` / `p check -tc -s `). Counterexample traces are NOT committed (neither the human-readable @@ -220,8 +221,10 @@ dropped). The seal clause deliberately compares against the last LIST, not truth-at-seal: a completed-then-crash schedule seals attempt 1's answer legitimately (sync-scoped freshness). The axes are `extRecon` (TRUE = the shipped capable-engine path; FALSE = the warn-and-continue -degrade of a non-deleting engine) and `extStaleList` (the recency -mutant: attempts ≥ 2 consume the sync-start answer): +degrade of a non-deleting engine), `extStaleList` (the recency +mutant: attempts ≥ 2 consume the sync-start answer), and +`extOverDelete` (the late over-deleting sweep — a seal-prep deletion +whose predicate mistakes a live principal for stale): | cell | config | property | expected | observed | budget | |---|---|---|---|---|---| @@ -230,6 +233,7 @@ mutant: attempts ≥ 2 consume the sync-start answer): | tc8stop_P8 | graceful stop + shrink, capable engine | P8 | GREEN | GREEN — restart-from-root re-lists; no mid-phase cursor can copy a fresh answer over a stale reconciliation | 10000 schedules | | tc8reconOff_P8 | crash + shrink, `extRecon` OFF (non-deleting engine) | P8 | RED | RED: `P8-EXT-STALE` — the warn-and-continue degrade seals the dead attempt's principal 1 (the SQLite degradation pinned by `SQLiteExternalPrincipalResumeDegradesWithoutFailure`, now model-caught) | first find (20% of explored) | | tc8staleList_P8 | crash + shrink, `extStaleList` ON (resume consumes the dead attempt's answer) | P8 | RED | RED: `P8-EXT-CURRENT` — the recency mutant the `ResumeUsesCurrentExternalAnswer` chaos pin forbids | first find (100% of explored) | +| tc8overDelete_P8 | no interruption, `extOverDelete` ON (late over-deleting sweep) | P8 | RED | RED: `P8-EXT-MISSING` — the over-deletion direction of the seal clause, witnessed so P8 is calibrated in both directions (the P6-C ZOMBIE/AMNESIA pattern). MODEL FACT the kill's placement records: an over-deleting EARLY pass — the engine order, delete-stale before copy — cannot produce this shape in ANY schedule, because the page-1 copy rewrites every listed id (structural self-heal); the mutant therefore models a late sweep committing at seal prep, where nothing re-writes the row (`Store.p`'s `extSweepMutant`) | first find (100% of explored) | ## P4 tranche — progress properties (stuck-resume, ladder, leaked lock) diff --git a/formal/walker/PCheckerOutput/sweep/summary.txt b/formal/walker/PCheckerOutput/sweep/summary.txt index 650afb0b2..3281d4b19 100644 --- a/formal/walker/PCheckerOutput/sweep/summary.txt +++ b/formal/walker/PCheckerOutput/sweep/summary.txt @@ -13,7 +13,7 @@ tc2green_P6A expected=GREEN observed=GREEN ok tc2crash_P6C expected=RED observed=RED ok [P6-C-ZOMBIE,P6C] tc2clear_P6C expected=RED observed=RED ok [P6-C-AMNESIA,P6C] tc2consistent_P6C expected=GREEN observed=GREEN ok -tc3a_P1 expected=RED observed=RED ok [P1-CONTENT] +tc3a_P1 expected=RED observed=RED ok [P1-ATTEST-SEAL] tc3a_P2 expected=GREEN observed=GREEN ok tc3b_P1 expected=RED observed=RED ok [P1-ATTEST-SEAL] tc3bBindingOn_All expected=GREEN observed=GREEN ok @@ -53,4 +53,5 @@ tc8crash_P8 expected=GREEN observed=GREEN ok tc8stop_P8 expected=GREEN observed=GREEN ok tc8reconOff_P8 expected=RED observed=RED ok [P8-EXT-STALE] tc8staleList_P8 expected=RED observed=RED ok [P8-EXT-CURRENT] -SWEEP-DONE cells=55 mismatches=0 +tc8overDelete_P8 expected=RED observed=RED ok [P8-EXT-MISSING] +SWEEP-DONE cells=56 mismatches=0 diff --git a/formal/walker/PSrc/Env.p b/formal/walker/PSrc/Env.p index edc9d16bc..a116cae8f 100644 --- a/formal/walker/PSrc/Env.p +++ b/formal/walker/PSrc/Env.p @@ -67,7 +67,7 @@ machine MEnv { if (cfg.verificationOnlyIfInterrupted && syncN == cfg.nSyncs && !interrupted) { break; } - send store, eStoreReset, (client = this, syncN = syncN, sessVariant = cfg.sessVariant); + send store, eStoreReset, (client = this, syncN = syncN, sessVariant = cfg.sessVariant, extOverDelete = cfg.extOverDelete); receive { case eStoreAck: {} } announce eAnnSyncStart, (syncN = syncN,); if (cfg.cell == 7) { diff --git a/formal/walker/PSrc/Events.p b/formal/walker/PSrc/Events.p index ccca9e354..20d096059 100644 --- a/formal/walker/PSrc/Events.p +++ b/formal/walker/PSrc/Events.p @@ -58,7 +58,7 @@ event eStoreDead; // terminates. event eCrashArm: (client: machine, gen: int); event eCrashAck; -event eStoreReset: (client: machine, syncN: int, sessVariant: int); // begin-of-sync rotation (env, not gen-gated) +event eStoreReset: (client: machine, syncN: int, sessVariant: int, extOverDelete: bool); // begin-of-sync rotation (env, not gen-gated) event eReadCheckpointReq: (client: machine); event eReadCheckpointResp: (ckpt: tCheckpoint, hasCkpt: bool); // Session store (MODEL_SPEC 3/9 cases 2 and 7): sync-scoped KV, durable diff --git a/formal/walker/PSrc/Store.p b/formal/walker/PSrc/Store.p index 0ec894ad3..032e38ecf 100644 --- a/formal/walker/PSrc/Store.p +++ b/formal/walker/PSrc/Store.p @@ -50,9 +50,12 @@ machine MStore { // row write: a dead attempt's committed copies SURVIVE the crash — // which is exactly why eExtReconReq exists. var extRows: map[int, bool]; + // Scenario-8 over-deletion mutant (cfg.extOverDelete; the + // P8-EXT-MISSING kill). See extSweepMutant below. + var extOverDelete: bool; start state Serving { - on eStoreReset do (p: (client: machine, syncN: int, sessVariant: int)) { + on eStoreReset do (p: (client: machine, syncN: int, sessVariant: int, extOverDelete: bool)) { // Begin-of-sync rotation: the sealed artifact becomes the // replay source; the new artifact starts empty; the // checkpoint token belongs to a sync and does not survive it. @@ -73,6 +76,7 @@ machine MStore { sessVariant = p.sessVariant; sessCkpt = default(map[int, int]); extRows = default(map[int, bool]); + extOverDelete = p.extOverDelete; hasCkpt = false; ckpt = default(tCheckpoint); sealed = false; @@ -387,6 +391,7 @@ machine MStore { } else { sealed = true; sealedBlocked = p.blocked; + extSweepMutant(); announce eAnnExtSeal, (syncN = syncN, ids = keys(extRows)); announce eAnnSeal, (syncN = syncN, partition = curPart, manifest = curMan, blocked = p.blocked, config = p.config); send p.client, eStoreAck; @@ -397,6 +402,7 @@ machine MStore { if (p.gen in deadGens) { send p.client, eStoreDead; return; } sealed = true; sealedBlocked = p.blocked; + extSweepMutant(); announce eAnnExtSeal, (syncN = syncN, ids = keys(extRows)); announce eAnnSeal, (syncN = syncN, partition = curPart, manifest = curMan, blocked = p.blocked, config = p.config); send p.client, eStoreAck; @@ -445,6 +451,23 @@ machine MStore { announce eAnnCrash, (syncN = syncN,); send armedClient, eCrashAck; } + + // The over-deletion inject (tc8overDelete_P8's kill, the + // P8-EXT-MISSING witness): a LATE deleteStaleExternalPrincipals + // sweep whose predicate mistakes a live principal for stale, + // committing at seal prep where nothing re-writes the row. + // Injected at the seal and not in eExtReconReq because the + // engine-ordered early pass is structurally self-healing for + // over-deletion: it runs before the page-1 copy, which rewrites + // every listed id — an early over-delete cannot survive to seal + // in any schedule (recorded in the scenario-8 calibration). + fun extSweepMutant() { + var ks: seq[int]; + if (!extOverDelete) { return; } + if (sizeof(extRows) == 0) { return; } + ks = keys(extRows); + extRows -= (ks[0]); + } } fun prevManValue(m: map[int, int], scope: int): int { diff --git a/formal/walker/PSrc/Types.p b/formal/walker/PSrc/Types.p index b0deed688..ebdb5ca75 100644 --- a/formal/walker/PSrc/Types.p +++ b/formal/walker/PSrc/Types.p @@ -168,7 +168,15 @@ type tScenarioCfg = ( // instead of the current one (the behavior the // ResumeUsesCurrentExternalAnswer chaos pin forbids). extRecon: bool, - extStaleList: bool + extStaleList: bool, + // extOverDelete is the over-deletion mutant (P8-EXT-MISSING kill): + // a LATE stale-principal sweep whose predicate mistakes a live + // principal for stale, running at seal prep where nothing re-writes + // the row. It is injected at the seal (Store.p) and NOT in + // eExtReconReq because the engine-ordered early pass is + // structurally self-healing for over-deletion — the page-1 copy + // rewrites every listed id (see the scenario-8 calibration notes). + extOverDelete: bool ); // Base config: shipped design, no interruption, no mutation, 2 syncs. @@ -197,7 +205,8 @@ fun defaultCfg(): tScenarioCfg { o4Mutant = false, sessVariant = 0, extRecon = true, - extStaleList = false + extStaleList = false, + extOverDelete = false ); } diff --git a/formal/walker/PTst/Scenario8.p b/formal/walker/PTst/Scenario8.p index 611ffb818..2f55df099 100644 --- a/formal/walker/PTst/Scenario8.p +++ b/formal/walker/PTst/Scenario8.p @@ -26,7 +26,15 @@ SQLiteExternalPrincipalResumeDegradesWithoutFailure). - tc8staleList_P8 (crash + shrink, resume consumes the dead attempt's answer): RED on P8-EXT-CURRENT — the recency mutant the - ResumeUsesCurrentExternalAnswer chaos pin forbids. */ + ResumeUsesCurrentExternalAnswer chaos pin forbids. + - tc8overDelete_P8 (no interruption; LATE over-deleting sweep): + RED on P8-EXT-MISSING — the over-deletion direction of the seal + clause, witnessed so the clause is calibrated in both directions + like P6-C and the Occult ext policy. The mutant deletes a live + principal at seal prep; it CANNOT be modeled in eExtReconReq + because the engine-ordered early pass runs before the page-1 + copy, which rewrites every listed id — early over-deletion is + structurally self-healing (see Store.p's extSweepMutant). */ machine Test8Green { start state I { @@ -90,6 +98,20 @@ machine Test8ReconOff { } } +machine Test8OverDelete { + start state I { + entry { + var c: tScenarioCfg; + c = defaultCfg(); + c.scenario = 8; + c.cell = 8; + c.nSyncs = 1; + c.extOverDelete = true; + new MEnv(c); + } + } +} + machine Test8StaleList { start state I { entry { @@ -113,6 +135,8 @@ test tc8green_P8 [main=Test8Green]: assert P8 in (union Walker, { Test8Green }); test tc8crash_P8 [main=Test8Crash]: assert P8 in (union Walker, { Test8Crash }); test tc8stop_P8 [main=Test8Stop]: assert P8 in (union Walker, { Test8Stop }); -// Expected RED (the degrade path's debris; the recency mutant): +// Expected RED (the degrade path's debris; the recency mutant; the +// over-deleting late sweep): test tc8reconOff_P8 [main=Test8ReconOff]: assert P8 in (union Walker, { Test8ReconOff }); test tc8staleList_P8 [main=Test8StaleList]: assert P8 in (union Walker, { Test8StaleList }); +test tc8overDelete_P8 [main=Test8OverDelete]: assert P8 in (union Walker, { Test8OverDelete }); diff --git a/formal/walker/tools/sweep.sh b/formal/walker/tools/sweep.sh index 9a3bf4665..3c1cd76af 100755 --- a/formal/walker/tools/sweep.sh +++ b/formal/walker/tools/sweep.sh @@ -82,6 +82,7 @@ tc8crash_P8:GREEN tc8stop_P8:GREEN tc8reconOff_P8:RED tc8staleList_P8:RED +tc8overDelete_P8:RED " mismatches=0 From e9c89b7fe76c1c4a775d65751859243a7ed43179 Mon Sep 17 00:00:00 2001 From: Matt Kaniaris Date: Tue, 1 Sep 2026 12:06:47 -0600 Subject: [PATCH 12/12] formal: walker log carries its own coverage limit; tc3a_P1 row states the two-shape contract MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Both doc-only, closing the round-6 bot pass: the tc3a_P1 row now states its conformance contract explicitly (either P1-CONTENT or P1-ATTEST-SEAL is calibrated — which trips first is seed luck — and any OTHER alarm is real drift), so a reader diffing the run of record against this log has a check for the shape flip instead of a stale "first find" claim; and the walker log now carries the mirror of the graph's COVERAGE LIMIT block (P1-ATTEST-EMPTY, P1-ATTEST-PUBLISH, P2-CONSULT are asserted, not calibrated), kept minimal with the shared doctrine pointed at REPORT.md to avoid a third drifting copy. Co-authored-by: Cursor --- formal/walker/CALIBRATION.md | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/formal/walker/CALIBRATION.md b/formal/walker/CALIBRATION.md index 2cb0a08a9..c9d44a39c 100644 --- a/formal/walker/CALIBRATION.md +++ b/formal/walker/CALIBRATION.md @@ -29,6 +29,15 @@ also clean, isolating the P4 merge from the v11 monitor change), the +5 scenario-8 cells (55), and the tc8overDelete_P8 over-deletion kill (the current 56). +COVERAGE LIMIT of the 56-cell matrix (the graph log carries the +mirror block for its leg; shared doctrine and both inventories in +REPORT.md's standing limits): three of this model's alarm strings +fire in no red cell — P1-ATTEST-EMPTY, P1-ATTEST-PUBLISH, and +P2-CONSULT. Each is a narrower sibling of a witnessed clause on the +same monitor (P1-ATTEST-SEAL, P1-CONTENT, and P2-STALENESS all have +reds); by this log's own doctrine the three are asserted, not +calibrated, and a green matrix says nothing about them. + Toolchain: P 3.1.0 (`p compile` / `p check -tc -s `). Counterexample traces are NOT committed (neither the human-readable schedule nor the machine-replay `trace.json`): archived traces rot @@ -109,7 +118,7 @@ validators): | cell | config | property | expected | observed | budget | |---|---|---|---|---|---| -| tc3a_P1 | shipped (`hitValidatorBinding` ON) — the residual hole | P1 | RED | RED: `P1-CONTENT` is the archived sweep's first find (carrier-first/interleaved content shape); the `P1-ATTEST-SEAL` carrier-last shape (rows(B) sealed under entry V_A) is also live in the config — both require the re-consult's lookup-hit V_B to OVERWRITE the hit map before the carrier's LIVE hit read (last-write-wins rebind) | first find (0.34% of 10k — narrow: needs C dispatched after P's re-consult transition) | +| tc3a_P1 | shipped (`hitValidatorBinding` ON) — the residual hole | P1 | RED | RED: TWO calibrated shapes are live in this config and the run of record may show EITHER as its first find — `P1-CONTENT` (carrier-first/interleaved content shape) or `P1-ATTEST-SEAL` (carrier-last: rows(B) sealed under entry V_A); which trips first is seed luck (the Makefile's formal-section note on multi-shape RED tag noise names this cell). The conformance contract for a differ: either of those two alarms is calibrated; any OTHER alarm on this cell is a real drift. Both shapes require the re-consult's lookup-hit V_B to OVERWRITE the hit map before the carrier's LIVE hit read (last-write-wins rebind) | first find (0.34% of 10k — narrow: needs C dispatched after P's re-consult transition) | | tc3a_P2 | same config | P2 | GREEN | GREEN — attempt 1's validation match qualifies the scope as consulted; copied rows carry hops 1 (corrected expectation; spec v2 wrongly claimed a P2 red) | 10000 schedules | | tc3b_P1 | pre-CO-6b-004 (`hitValidatorBinding` OFF), 1-page planning (cell 31) | P1 | RED | RED: `P1-ATTEST-SEAL` — no re-consult, hit stays V_A, NO binding check; carrier copies swapped B and publishes V_A | first find (100% of explored) | | tc3bBindingOn_All | same premise, binding ON — the CO-6b-004 kill | P1+P2+P3′ | GREEN | GREEN — binding gate compares hit V_A to base V_B, fails LOUD-COLD (behavior, not assert); scope seals empty in premise schedules, no wrong data | 10000 schedules |