Echo's write-ahead log is the durable commit boundary for causal history. Applications submit canonical intents. A trusted Echo host admits those intents, records the accepted-submission fact, schedules lawful work, records decided tick evidence, and exposes outcomes only after the relevant WAL fact is committed.
The short rule is:
Echo may only claim what its WAL can recover.
Batched strict submission states how a host submits several intents behind one commit step, and what an acknowledgement means for each store. Only the filesystem store syncs storage in that step; the in-memory store has no storage to sync.
The current runtime WAL evidence says twelve concrete things.
First, accepted-submission evidence is not just an in-memory editor event. The
WAL-backed ACK path, submit_intent_with_runtime_wal_ack(...), returns only
after the runtime WAL has committed the submission-acceptance transaction. That
acceptance fact recovers as an AcceptedPending submission if the scheduler has
not yet produced a decided outcome.
submit_intents_with_runtime_wal_ack(...) accepts several intents in order
and returns after one storage sync covers all of their acceptance
transactions. Each intent still writes its own acceptance transaction, so
recovery reads a batch exactly as it reads single submissions. Until that sync
succeeds, no acceptance of the batch counts as durable and none can be
scheduled. A batch is not atomic across a crash: a prefix can survive, none of
it acknowledged, and each survivor recovers as AcceptedPending.
An intent that repeats a submission Echo already holds is a duplicate: it writes no transaction and its handle names the existing submission. An empty batch, and a batch of duplicates only, writes nothing and forces no sync.
If the runtime or the WAL refuses an intent of a batch before anything is written for it, the intents before it are still synced and stay accepted; the call returns the refusal and no handles.
If storage fails during an append or the shared sync, Echo rolls back the
in-memory intake of every submission that call accepted, returns the storage
error, and refuses further WAL work with StorageFailed until the host
reopens the WAL. A record that is readable after a storage failure is not
treated as durable by the running host.
A host that opens an existing log, and a writer that takes it over, sync its segment files before reading them as recovered history. An earlier writer may have stopped, or failed a sync, after writing records; those records are readable and not yet durable. If that sync fails, the host does not open the log and the writer does not take it over.
Second, failed WAL acceptance is not allowed to leave half-visible runtime state. If no runtime WAL is configured, the ACK path returns an explicit unavailable error before mutating intake state. If WAL commit fails, Echo rolls back the in-memory intake mutation before returning the error.
A commit record can reach the log and then fail its storage sync. The record
is readable and is not durable, and a readable record is not a durable one.
When that happens for any transaction, whether a submission, a scheduler tick,
a causal anchor, an operation installation or an operation tick, Echo takes
back the in-memory effect, acknowledges nothing, and refuses further WAL work
with StorageFailed until the host reopens the WAL. It does not re-read the
log to see whether the record is there. A host that reopens the log syncs it
first, so a record that did reach storage recovers then.
An error that arrives after a commit record was written and synced is a different case: the record is durable, so the host re-reads the log and acknowledges what it finds.
Third, tick receipts are published only after scheduler-tick WAL evidence is committed. Recovery can rebuild both the submission posture and the receipt index from committed WAL facts. If tick WAL recording fails, Echo rolls back the visible receipt/outcome instead of exposing a receipt that recovery cannot rebuild.
Fourth, read-only recovery rebuilds submission and receipt indexes from the WAL without scheduler callbacks, application callbacks, wall-clock interpretation, or external I/O. Recovery also emits a certificate over the committed replay range and recovered index root.
Fifth, an admitted intent may cite typed causal parent tick receipts. Echo does not interpret a parent as undo, redo, compensation, or any other application operation. It commits the citation with the child receipt and rebuilds both parent lookup and reverse child lookup during read-only recovery. A contract can therefore define inverse semantics while Echo preserves the provenance chain across process loss. Recovery rejects explicitly empty, duplicated, or out-of-order parent receipt coordinates instead of normalizing committed non-canonical bytes. Before exposing a recovered correlation, it also requires that correlation's parent set to match the independently retained ingress envelope.
Sixth, trusted submission intake commits the canonical retained ingress envelope
in the same transaction as acceptance evidence. Reopening a filesystem WAL can
restore witnessed submission identity, generation, route, payload, and causal
parents without scheduler or contract callbacks. Legacy acceptance records that
lack envelope material remain inspectable, but recovery reports them as
obstructed and the trusted host refuses to claim a complete replay.
Transaction construction rejects any retained envelope whose submission or
canonical-envelope identity disagrees with its acceptance record.
Recovery requires exactly one acceptance frame and at most one retained
envelope frame in each intake transaction. An envelope that admits a Continuum
occurrence is retained as EINGR003, which keeps the occurrence key and
applied digest; recovery rebuilds the occurrence admission mapping from it.
Seventh, a scheduler-tick transaction for ticketed runtime ingress retains the
canonical local-commit provenance entry, its exact typed TickReceipt, and any
installed-invocation identity attached to the outcome. That identity is a
tagged proposition: the existing legacy Wesley/GraphQL evidence keeps its
byte-stable tag-1 encoding, while tag 2 retains provider package id and exact
reference, operation id and coordinate, Target IR identity, and scheduler rule
id. Provider installation applies the same pure package-reference and
operation/Target-IR structural checks used by retained decoding before changing
any Engine index. Provider proposal construction rejects Echo-reserved
operation ids before installation; retained decoding independently rejects
those ids, empty coordinates, and malformed package or Target IR digests rather
than laundering structurally invalid fields through a valid WAL frame checksum.
Provider evidence does not fabricate a legacy retained-contract coordinate.
Every tick receipt written since #873 also carries an attribution section: one
record per accepted submission the tick decided, in submission order, naming
either the receipt entries that carry its decision or that no rule matched it.
The scheduler seals that section from the tick's own batch and refuses to
commit a tick whose decisions and receipt entries disagree. Every new scheduler
tick's receipt is commit-bound (receipt format 4) and retained as EPRV0003,
and the tick is committed with commit hash v3, which hashes the receipt digest:
commit hash → receipt digest → attribution. Two historical formats are read
unchanged and keep commit hash v2: EPRV0002, an attributed but unbound
receipt written between attribution and commit binding, and EPRV0001, a
legacy receipt with no section. See
the commit-hash specification.
Filesystem WAL reopen loads that evidence into a fresh provenance service, replays the worldline from its deterministic registered boundary, restores receipt correlations, and only then publishes the reconstructed runtime. The recovery witness compares global tick, frontier tick, state root, provenance, receipt, contract evidence, and the app-facing outcome without running the scheduler or contract handler. A fresh host may then independently reinstall the same provider package as host configuration; recovered invocation remains idempotent and does not become duplicate scheduler work. A legacy digest-only state-delta record is inspectable but obstructs writable startup. Transaction construction also requires the receipt and correlation to name the same causal event and the retained state delta to bind that receipt's content commitment before the transaction can commit. Legacy singleton scheduler transactions contain exactly one receipt, correlation, and runtime state-delta frame. Scheduler-owned executable-operation Action Ticks instead retain exactly one batched Tick receipt record containing every per-Action decision, one ordered correlation and typed Action-outcome pair per selected Action, and exactly one runtime state delta for the whole Tick. Recovery rejects missing, duplicated, reordered, mixed, or cross-Tick claims rather than selecting whichever frame appears first. WAL activation is non-lossy: if the live host contains submissions, staged ingress, receipt correlations, provenance, pending inbox work, cycle progress, or worldline state that recovered WAL evidence cannot reproduce, activation fails instead of treating process memory as durable authority.
Eighth, causal-anchor admission has its own admission-kernel authority, transaction kind, fact record, receipt record, and affected frontier. The canonical claim contains no receipt identity. Echo derives that identity from the claim, host support-policy digest, and WAL coordinate, commits the fact and receipt in one transaction, and recovers only complete, internally consistent pairs. Uncommitted frames do not become admitted anchors; malformed payloads, unknown enum codes, trailing bytes, missing or duplicate required frames, mismatched fact/receipt evidence, noncanonical frame order, and mismatched WAL coordinates are rejected. The trusted-host API requires the current logical durable frontier and exact host-installed root support before invoking this transition, and returns only after commit.
Ninth, executable-operation installation and commitment use their own append-only transaction kinds, record kinds, affected frontiers, and authorities. Runtime-control authority retains the exact canonical operation package together with its complete package-admission policy. Fresh-host recovery canonical-decodes the package, recomputes every identity, reconstructs the policy identity, and runs the same package-admission checks before restoring the installed operation. It does not resolve or invoke application callbacks. Execution-kernel authority separately retains one committed typed operation receipt and its replayable state delta. Recovery requires exactly one of each, revalidates the receipt's internal result evidence, checks the state delta's basis, installed-operation rule identity, patch, tick, and state-root correspondence, and reconstructs the installed and execution indexes idempotently. Each new transaction kind rejects missing, duplicate, reversed, or mis-scoped frame/frontier shapes. These records do not make a naked program digest invocable and do not persist the process-local authority needed to commit an unretained preparation.
Tenth, canonical executable-operation Actions use the ordinary WAL-backed submission acknowledgement before execution. A crash after acknowledgement and before scheduler selection restores accepted pending work. Runtime-owned admission resolves the exact installed package, but only scheduler Tick construction invokes private bounded evaluation. Two independent Actions can produce one composite Tick with one snapshot, one provenance entry, one frontier advance, per-Action typed outcomes, and one replayable state delta.
The scheduler transaction commits before state, frontier, receipt, or Action outcome publication. Construction and WAL failures publish none of them. A typed evaluator obstruction is retained as a lawful no-mutation Tick entry. Fresh-host recovery binds each Action outcome back to its exact retained envelope, invocation identity, installed operation, scope, Tick entry, disposition, blocker set, composite patch, and final state root. Swapped or misclassified outcome evidence therefore fails closed.
Eleventh, external actions use a separate request, claim, and settlement
protocol under Echo-owned ExternalActionCoordinator authority. The canonical
request commits its originating worldline, operation family, input and
settlement schemas, authority scope, exact basis, retained-result and
single-claim budgets, input digest, and reconciliation law. Echo flushes the
request transaction before it can return a claimable token, and flushes the
claim transaction before it can return adapter work authority. The compiler,
provider seam, Edict program, and application receive no filesystem, process,
network, or model authority from those values.
The runtime-owned registry decision is bound to the exact request, basis, and
canonical registry-policy digest. Every transition advances an
ExternalActionIndex frontier whose before and after roots Echo derives from
the complete lifecycle index through a request-id-keyed sparse Merkle
commitment. Recovery recomputes those roots and rejects caller-selected or
substituted frontier evidence. The live coordinator advances one planned
256-bit Merkle path after each successful commit; it does not replay the full
WAL on every transition. Full reconstruction is reserved for initial and crash
recovery.
An admitted settlement binds the exact request, attempt, adapter, basis,
settlement schema, canonical result bytes, result digest, schema-admission
evidence, and nonzero external evidence. It has one of four explicit outcomes:
Succeeded, Rejected, Failed, or OutcomeUnknown. Echo flushes the
settlement before exposing the result to deterministic resumption. Recovery
reconstructs REQUESTED, CLAIMED, or the exact settled outcome using only
committed records. It rejects missing predecessors, duplicate requests or
claims, conflicting settlements, malformed payloads, wrong schemas, stale
bases, digest substitution, and budget overruns. A recovered claim is a
reconciliation obligation rather than permission to reissue an effect.
Settled replay, including strict filesystem WAL reopen, consumes retained
result bytes without consulting an adapter. Arbitrary recovery reports are
observation-only. Only a coordinator recovered from one fallible local-store
snapshot can reconstruct request tokens, claim grants, or resumable settlement
facts. Raw WAL builders and commit flushes lack its opaque capability, and the
coordinator derives LSN and predecessor coordinates from the validated local
continuation.
The first operation profile independently admits exact compiler-produced Edict Core and Target IR before deriving the generic request. Its capability-rooted workspace observer receives only a post-claim work grant and an explicit relative-path set. Successful settlement retains complete path/content bytes and a basis commitment; operation-specific schema validation runs before the generic settlement transaction. Replay consumes those retained bytes without opening the workspace again.
Twelfth, strict filesystem WAL writer authority survives process loss as a durable, checksummed epoch ledger rather than process memory. Epoch acquisition is persisted before the store returns authority. Every committed transaction then advances that epoch's final LSN and commit-digest evidence in the live store, and explicit closure persists the exact predecessor link. A commit's durability boundary is the sync of its commit record in the segment: the store does not rewrite the ledger for each commit. The ledger file is written when an epoch is acquired or closed. Opening a store reads the ledger and derives each epoch's final commit from the committed records in the segment; that reconciliation updates the live view and does not write the file. The ledger retains the active epoch and only its latest closed predecessor; the trusted successor identity recursively commits the preceding epoch identity and final commit while older transactions remain in the WAL. Reopen cost and ledger size therefore remain bounded, and reconciliation still admits a commit that reached its segment sync boundary before the ledger snapshot.
The filesystem store holds an operating-system writer lease for the complete active epoch. A second live process cannot append, close, or replace that epoch. After process loss releases the lease, the trusted runtime closes the recovered active epoch under the newly acquired lease and derives a fresh successor with a monotonic start LSN, new epoch identity, fencing token, and lease evidence bound to the exact latest predecessor and its final commit. Duplicate identities, stale or missing predecessor links, reused fencing evidence, LSN regression, corrupted ledgers, and commits without their epoch ledger fail closed before append.
The store's internal lease guard explicitly attempts to unlock before its file
descriptor closes, both when the store drops and when close_epoch releases
the guard after persisting the closed epoch. This avoids extending that owner's
lease merely because another descriptor retains the same open file description,
as can happen between fork and exec. Closing only one descriptor is insufficient
under Rust's file-lock lifetime contract.
Drop is a best-effort fallback: it cannot return an unlock error and does not
prove release succeeded after an OS error. A contender must still acquire its
own lock. Explicit fallible release and the broader process-bound ownership
contract remain in issue #718.
The operating-system lease is the filesystem adapter's exclusion authority. The persisted fencing, process, host, and lease fields are deterministic chain-position markers, not ambient PID or machine measurements and not a second lock. Their distinct values make epoch transitions attributable and replayable without sampling time, randomness, or global process state. This generic WAL authority contains no application vocabulary or callback.
The WAL belongs to the trusted runtime host. Application-facing code can submit intents and observe outcomes, but it cannot append WAL records, tick the scheduler, install packages, stage ticketed ingress, or perform trusted recovery.
That split matters because an accepted edit is not durable because an editor buffer says it is dirty, because a file was written to disk, or because a UI event happened. It is durable because Echo recorded the accepted submission and later recorded any decided receipt under host-owned WAL authority.
State roots cover reachable WARP state. A detached create-if-absent cell can leave the root unchanged. The retained patch and commit bind that write. Root equality alone is not a complete recovery or no-mutation witness.
Action parent-state validation indexes verification obligations by exact worldline and tick. A first sweep checks receipt and Action basis obligations, including delayed and cross-worldline bases. A second sweep reconstructs composite Tick decisions from their scheduler Tick parents. Ordered cursors reuse verified prefixes within each sweep. Raw retained decision order remains authoritative. Initial-boundary, checkpoint, patch, commit, result, obstruction, and conflict checks remain required.
Each validation call retains one replay cursor per needed worldline and one transient Tick simulation. Replay-patch applications stay within two history sweeps. This bounds repeated prefix work and private snapshot retention; it does not claim linear elapsed time. State hashing and Tick simulation still depend on graph size. Test-only counters measure applied patches and logical retained data without becoming causal authority.
echo-cli --format json wal submission-posture projects a matching recovered
receipt into named receipt_coordinate fields: its identity digest,
worldline, worldline and global ticks, commit, submission, ticket, and receipt
content digest. The existing receipt_ref remains the hex-encoded canonical
coordinate. Both come from the recovered receipt; neither grants admission or
changes history. A coordinate can name a rejected or obstructed decision.
Without a matching receipt, including an envelope conflict, the structured
coordinate is null.
The CLI integration tests compare all named fields with a real host-produced receipt after filesystem recovery and check pending, unknown, conflicting, rejected, and obstructed postures.
The useful postures are:
| Posture | Meaning |
|---|---|
not_accepted |
The intent never reached WAL-backed accepted submission posture. |
accepted_pending |
Accepted-submission evidence was recovered, but no decided receipt was recovered. |
decided_applied |
A recovered receipt says the work applied under named law. |
decided_rejected |
A recovered receipt says the work was rejected or conflicted. |
obstructed |
Recovery found accepted or decided evidence, but required material or consistency checks obstruct restoring the work. |
recovery_faulted |
Required committed WAL evidence or retained material is missing or corrupt. |
External-action recovery has its own narrower lifecycle:
| Posture | Meaning |
|---|---|
REQUESTED |
The request commit exists; no adapter claim is committed. |
CLAIMED |
One bounded claim exists; recovery must reconcile and must not blindly execute again. |
SETTLED(SUCCEEDED) |
The external postcondition was witnessed and admitted. |
SETTLED(REJECTED) |
The external system's typed refusal was witnessed and admitted. |
SETTLED(FAILED) |
A definite adapter failure was witnessed and admitted. |
SETTLED(OUTCOME_UNKNOWN) |
The external outcome is ambiguous and remains explicit causal evidence. |
An app such as jedit maps these generic postures into product language
outside Echo. Echo should not grow editor, file, buffer, or dirty-state nouns in
order to explain them.
For Jim/jedit, "dirty" should not mean "at risk of being lost." It should mean "not currently materialized to the host file projection." If an edit intent has received WAL-backed accepted-submission evidence, the edit's identity and posture belong to recoverable causal history even before the host file is written. Restoring the editor text still requires retained material, a decided receipt, or a recovered reading that carries the content needed for the view. If that content is unavailable, the editor must keep the materialization warning and surface the recovered obstruction instead of claiming the buffer can be rebuilt from an ACK alone.
The correct safety gate is therefore not a classic dirty-buffer warning on quit or file switch. The correct gate is whether the edit crossed the Echo WAL-backed ACK boundary and whether recovery can later classify it as pending, decided, rejected, or obstructed. If that boundary is unavailable, the editor must say so honestly instead of pretending a local buffer is causal history.
Restored submission material alone is not runtime-state replay. For WAL-backed ticketed transitions, the trusted host now also requires replayable provenance and the exact tick receipt, then restores the materialized worldline and outcome before allowing writable startup. That is the causal authority Jim needs for durable edit history. It is still not complete editor-session restoration: viewport, cursor, mode, open-buffer topology, and other application projections must be expressed as admitted application intents and recovered readings rather than inferred from the text worldline.
The same rule applies to topology. A strand fork, braid creation, member weave, braid settlement, braid collapse, or replica suffix import should not be a side-channel runtime call. Each one is a topology intent that changes causal history or the geometry through which causal history is interpreted.
The current braid and strand implementation already has typed strand construction, braid event logs, settlement provenance entries, retained braid shells, and replay/audit optics. Topology operations do not currently have WAL-backed accepted evidence or recoverable WSC-retained material. Echo must not claim that braid shells and topology indexes have the same explicit crash-recovery posture as tick receipts. They are causal/provenance entities with retained replay shapes, not evidence of WAL/WSC topology recovery.
WAL bytes are the durable commit authority. WARP graph facts can track WAL segment evidence, and WSC can serialize graph facts plus WAL references or bundled WAL material, but neither graph facts nor WSC replace the WAL commit boundary.
A WAL path is a storage locator, not causal identity. Causal identity comes from the writer epoch, LSN range, segment digest, commit digest chain, and validated commit anchors.
Recovery planning records the bootstrap source, optional checkpoint posture, committed replay suffix, tail posture, recovered index roots, retained-material posture, and projected evidence posture. A recovery plan may start from a projected WAL root or storage manifest, but it does not require graph WAL nodes as recovery input.
Read-only recovery can rebuild durability indexes from committed transactions: submission posture, receipt/correlation, retained material, materialization outbox, topology, causal-anchor admissions, and graph/WSC projection posture. Uncommitted tail frames are reported through tail posture and do not appear in rebuilt indexes. Materialization outbox recovery reports typed posture for missing artifacts, artifact or metadata mismatches, committed observation mismatches, and retained material unavailability so restart logic can retry, repair, or obstruct without blindly replaying effects.
The process-kill crashpoint runner exercises the filesystem WAL across real parent/child process boundaries. A killed child that already committed WAL material recovers as committed history; a killed child with only uncommitted frames recovers as tail posture and does not enter accepted or decided history.
The durable vocabulary is precise:
- Records are recorded.
- Transactions are committed.
- Segments are sealed.
Graph facts are projected evidence. WSC carries or references that evidence; it does not become a second commit authority.
Release-grade durability requires all of the following executable claims:
- Recovery is deterministic from the same committed evidence.
- The defined crashpoint matrix passes.
- Duplicate replay is idempotent.
- Corrupt or incomplete evidence is deterministically rejected.
- Retained evidence survives restart or produces a typed obstruction.
- Required recovery artifacts are emitted by CI.
Filesystem writer takeover acquires the process lease and checks the recovered tail before closing a predecessor epoch. An uncommitted or torn tail refuses takeover until writable recovery reconciles it. Writable recovery rewrites segment files, so it is a write: a host takes the lease first, runs writable recovery under it, and only then admits its epoch. A host that opens a log held by a live writer is refused at the lease. It modifies nothing and syncs nothing: making a live writer's unsynced records durable is that writer's decision. An empty predecessor leaves its starting LSN unused, so a distinct linked successor may start at that same coordinate; a committed predecessor requires the successor to start after its final LSN, with overflow refused.
The runtime ACK and recovery witnesses live in
crates/warp-core/tests/trusted_runtime_host_loop_tests.rs.
The core test names to read first are:
batched_submission_makes_every_acceptance_durable_with_one_syncbatched_submission_handles_duplicates_and_an_empty_batchbatched_submission_refused_before_storage_keeps_earlier_intents_and_the_walbatched_submission_append_failure_fails_closed_until_the_wal_is_reopenedbatched_submission_sync_failure_rolls_back_intake_and_fails_closedruntime_wal_ack_submit_commits_acceptance_before_returning_handleruntime_wal_ack_path_requires_configured_runtime_walruntime_wal_ack_failure_rolls_back_intake_mutationruntime_wal_ack_tick_commits_receipt_transaction_before_outcome_is_observedruntime_wal_ack_tick_failure_rolls_back_visible_outcomeruntime_wal_ack_recover_read_only_rebuilds_submission_and_receipt_indexesruntime_wal_ack_recover_read_only_exposes_recovery_certificatefilesystem_runtime_wal_recovers_receipt_causal_parents_after_host_restartfilesystem_runtime_wal_restores_witnessed_submission_material_after_restartfilesystem_runtime_wal_recovers_replayable_provenance_after_restartruntime_wal_activation_rejects_process_only_committed_historysubmission_acceptance_rejects_mismatched_retained_materialtick_transaction_rejects_mismatched_receipt_correlationreplayable_tick_transaction_rejects_unrelated_state_delta_receipt
The canonical retained transition codec witnesses live in
crates/warp-core/tests/provenance_retention_codec_tests.rs. They cover every
current patch operation and slot variant, exact receipt and contract-evidence
round-trip, all truncation boundaries, trailing bytes, corrupt commitments,
missing receipts, and non-local events.
The causal-anchor WAL codec and recovery witnesses live in
crates/warp-core/tests/causal_anchor_wal_tests.rs. They cover stable persisted
codes, committed round-trip, uncommitted-tail invisibility, required-frame
cardinality, truncation, trailing bytes, malformed enum codes, cross-admission
evidence mismatch, and WAL-coordinate binding.
The hook-free executable-operation and filesystem-recovery witnesses live in
crates/warp-core/tests/executable_operation_pipeline_tests.rs. They cover
canonical package and invocation admission, authority and budget refusal,
exact-basis noncommit, program-substitution refusal, same-host preparation
authority, typed private-evaluation obstruction, deterministic duplicate-host
results, append-only WAL codes, activation refusal for process-only
installations, accepted-Action recovery, scheduler-owned decided Ticks, and
fresh-host installation and consequence recovery.
The external compiler-to-runtime singleton witness lives in
xtask/tests/run_edict_operation.rs. Its checked fixture contains exact package
and verification-report bytes emitted by the compiler build plus the exact
generator-owned manifest, target adapter, and target configuration inputs that
the build consumed. The runtime witness binds the executable-operation subset
of that closure; dormant declarative verifier, compatibility, and conformance
resource references remain Edict fixture identities rather than Echo runtime
inputs. Its report retains the input basis and node key, derived worldline and
node identities, accepted submission identity, committed Tick identity, and
typed Receipt identity. The witness proves
accepted-submission durability before acknowledgement, fresh-host recovery of
the installed package and pending Action before scheduler selection,
scheduler-owned evaluation of that recovered work, decided-Tick durability, a
second complete fresh-host recovery, a typed duplicate-create obstruction
without mutation, and recovery refusal when the registered initial state
changes. Duplicate no-mutation evidence consists of equal graph-only
application-state roots and equal typed target-value digests captured before
and after the obstructed Action. WAL frames, Tick history, Receipts, and commit
metadata are excluded from the application-state root because the obstruction
legitimately extends causal history. It uses the strict filesystem adapter and
no native application callback.
Filesystem writer-epoch and external-action process-loss witnesses live in
crates/warp-core/tests/causal_wal_hardening_tests.rs and
crates/warp-core/tests/external_action_protocol_tests.rs. Read these first:
filesystem_writer_lease_refuses_overlap_before_takeoverfilesystem_writer_epoch_chain_crosses_independent_processesfixed_seed_filesystem_writer_epoch_chain_survives_bounded_reopensfilesystem_external_action_lifecycle_crosses_independent_processes
The last witness uses four independent processes. Three processes durably record the request, claim, and settlement under successively fenced writer epochs. The fourth reconstructs and consumes the settled result without acquiring writer authority, appending a transaction, or reissuing an adapter effect.
For a successful projected Action, the decided-Tick transaction also retains the compiler-owned projection identity, output type coordinate, exact canonical application-result bytes, and their domain-separated result identity. Recovery deterministically re-evaluates the installed pure-data projection over the exact application input retained by the original invocation and requires byte-for-byte equality with that evidence before publishing the Action outcome or Receipt. This verification performs no native callback and reads no current application state. Rebound projection artifacts and substituted result bytes therefore fail closed. An obstructed Action carries no application result.
The Action/Tick witnesses to read first are:
accepted_executable_action_recovers_pending_before_scheduler_evaluationscheduler_commits_two_independent_executable_actions_in_one_durable_tickscheduler_tick_construction_failure_publishes_no_action_state_or_receiptscheduler_wal_failure_rolls_back_and_requeues_actiontyped_action_obstruction_is_durable_and_contributes_no_mutationfilesystem_wal_recovers_installed_meaning_consequence_and_typed_receipt
The host surface lives in crates/warp-core/src/trusted_runtime_host.rs,
especially TrustedRuntimeHost, TrustedRuntimeApp, TrustedRuntimeWal,
submit_intent_with_runtime_wal_ack(...), admit_causal_anchor(...),
causal_anchor_by_id(...), and recover_read_only().
TrustedRuntimeHostParts makes host decomposition identity-preserving:
into_parts() and from_parts(...) carry WAL, authority, policy, pending
admission, and typed Action outcomes together with runtime, provenance, and
engine ownership.
Related current authority lives in docs/topics/RuntimeAuthority.md,
docs/architecture/continuum-transport.md, and
docs/releases/echo-1.0-contract.md. Live release-hardening work and status
belong in GitHub.
The trusted-runtime suite uses both the fast in-memory adapter and the strict filesystem adapter. Filesystem witnesses now prove accepted-submission, ticketed-transition, and executable-operation replay across host reconstruction. The scheduler replayable state-delta path is currently emitted from ticketed receipt correlations; work committed through lower-level, non-ticketed scheduler ingress does not yet have the same trusted-host WAL reconstruction claim. Jim must therefore use a WAL-backed admitted-operation or application-intent path for user-facing edits and inverses instead of treating an internal runtime mutation as durable history.
WSC export/import shape, retained reading availability, multi-correlation tick packing, and complete application-session projection recovery remain separate gates. None of those gaps permits falling back to process-local undo authority.
cargo xtask dind now carries the dind_durability_convergence_gate witness
for the joined durability path. The gate commits one filesystem WAL history,
projects it through read-only recovery, imports the same causal evidence through
WSC, reveals retained reading material, and requires all paths to agree on the
same app-facing receipt and bounded reading. Missing CAS support material and
corrupt embedded retained bytes must surface as typed obstruction evidence
rather than a divergent success.
The WAL's release readiness is tracked on GitHub (#858), not here. No code checks the readiness gates together; an earlier aggregator only combined booleans its caller supplied and was removed (#820).
The builders for topology-intent, checkpoint-publication and
materialization-outbox transactions and the strict object-store validators exist only under test or host_test. They are
fixtures for the hardening tests that prove recovery understands those record
kinds. No production path writes those transactions or uses an object store.