Advance v18 release-candidate evidence

CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- V18 release-candidate evidence now records guarded CLI finalization,
+  zero-mismatch wet-run proof, runtime-boundary Continuum contract conformance,
+  `warp-ttd` generated-family smoke evidence, the retired raw-boundary
+  ratchet, remaining public-tag gates, and residual risks.
 - V18 migration evidence now includes a deterministic v17 golden graph-history
   fixture bundle, runtime-backed fixture manifest nouns, a manifest JSON
   adapter, and a restore validator that checks real `refs/warp/*` writer heads
@@ -184,6 +188,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- V18 release-candidate review follow-up now rejects empty production-runtime
+  replay repository paths, rejects empty scratch replay target fields with
+  structured invalid-target evidence, and reports confirmation JSON parse
+  failures with confirmation-specific context.
+- V18 release-candidate review follow-up now preserves structured
+  invalid-target replay evidence for malformed edge-property scratch owners,
+  classifies v17 fixture property owners from declared edge facts, and splits
+  migration script collaborators under the repository file-size cap.
+- V18 release-candidate review follow-up now binds reviewed finalization JSON
+  to runtime witness evidence, normalizes semantic finalization request
+  validation as adapter errors, adds edge-property coverage to the canonical
+  wet-run proof, and narrows production-runtime replay wording to the proven
+  scratch-operation replay path.
 - V18 graph-model migration review follow-up now preserves parent Git command
   environment variables under deterministic identities, validates scratch and
   finalization boundaries before Git work, rejects malformed scratch payload

docs/design/0203-v18-content-property-closeout-audit/v18-content-property-closeout-audit.md

@@ -66,7 +66,6 @@ The current audited files are:
 
 - `src/domain/graph/LegacyContentPropertyKeys.ts`
 - `src/domain/services/ContentAttachmentProjection.ts`
-- `src/domain/services/CoordinateFactExport.ts`
 - `src/domain/services/ImmutableSnapshot.ts`
 - `src/domain/services/JoinReducer.ts`
 - `src/domain/services/KeyCodec.ts`
@@ -91,14 +90,22 @@ The current audited files are:
 - `src/domain/types/ops/PropSet.ts`
 - `src/domain/types/ops/propHelpers.ts`
 
+## Retired Raw Compatibility Files
+
+Retired files must stay retired:
+
+- `src/domain/services/CoordinateFactExport.ts` retired in slice 93 after
+  transfer operation spelling moved behind constants owned by
+  `src/domain/services/transfer/transferOps.ts`.
+
 ## Classification
 
 These files fall into bounded categories:
 
 - Legacy content compatibility key ownership:
   `LegacyContentPropertyKeys`, `ContentAttachmentProjection`.
-- Fact export and coordinate comparison over existing operation shapes:
-  `CoordinateFactExport`, `CoordinateComparison`.
+- Coordinate comparison over existing operation shapes:
+  `CoordinateComparison`.
 - Runtime mutation and compatibility operation execution:
   `JoinReducer`, `OpStrategies`, `OpStrategy`, `PatchBuilder`,
   `PatchCommitter`, `StrandPatchService`, `transferOps`, and the op helper

docs/design/0214-v18-production-runtime-scratch-replay-conformance/v18-production-runtime-scratch-replay-conformance.md

@@ -0,0 +1,78 @@
+---
+cycle: 0214
+task_id: V18_production_runtime_scratch_replay_conformance
+status: Complete
+sponsors:
+  human: James
+  agent: Codex
+started_at: 2026-05-24
+completed_at: 2026-05-24
+release_home: v18.0.0
+bearing_task: 66
+---
+
+# V18 Production-Runtime Scratch Replay Conformance
+
+## Hill
+
+Define the conformance boundary that proves migrated scratch operations can
+drive the normal graph runtime write/materialization path instead of only
+proving that scratch operation commits can be parsed.
+
+## Current Evidence
+
+The operation-history provider reads `refs/warp-migration-scratch/*` commits
+and projects them into genesis-equivalence facts. That is useful, but it is not
+the same as replaying migrated graph operations through the production
+runtime. Public release claims need the latter and must not imply the scratch
+ref format is itself a native production graph-history format.
+
+## Design
+
+Production-runtime scratch replay is a separate adapter-level proof:
+
+- read the scratch ref at the expected scratch head;
+- decode the scratch migration operation stream deterministically;
+- replay those operations into an isolated normal git-warp runtime using the
+  public graph write/read surface;
+- materialize the resulting graph through the production runtime;
+- emit structured pass/fail evidence that can feed the existing finalization
+  safety gate.
+
+This remains non-destructive. The provider may create a disposable runtime
+repository for replay, but it must not update live `refs/warp/*` in the source
+repository.
+
+## User Story
+
+As a migration operator, I can see proof that scratch migration output replays
+through normal git-warp graph runtime behavior before I consider live-ref
+promotion.
+
+## Acceptance Criteria
+
+- Operation-history readback remains available but is no longer the strongest
+  runtime claim.
+- A new replay request names the graph id, scratch ref, expected scratch head,
+  and runtime writer id.
+- A new replay result reports passed or failed status, witness text, replayed
+  operation count, and fatal notices.
+- Failures are structured values for missing scratch refs, stale scratch heads,
+  unreadable scratch payloads, invalid operation targets, and runtime
+  materialization failures.
+- No production-runtime replay step writes source live refs.
+
+## Test Plan
+
+- Unit-test request/result constructor guards.
+- Add provider tests for a passing node-only scratch replay.
+- Add provider tests for missing scratch ref, stale scratch head, malformed
+  scratch payload, and invalid edge/property targets.
+- Add command or wet-run tests that prove finalization can consume the
+  production-runtime conformance result later.
+
+## Closeout
+
+This design splits "scratch history can be parsed" from "scratch operations can
+drive git-warp's normal runtime." Slices 67 and 68 implement the request/result
+nouns and provider.

docs/design/0215-v18-runtime-scratch-replay-nouns/v18-runtime-scratch-replay-nouns.md

@@ -0,0 +1,40 @@
+---
+cycle: 0215
+task_id: V18_runtime_scratch_replay_nouns
+status: Complete
+sponsors:
+  human: James
+  agent: Codex
+started_at: 2026-05-24
+completed_at: 2026-05-24
+release_home: v18.0.0
+bearing_task: 67
+---
+
+# V18 Runtime Scratch Replay Nouns
+
+## Hill
+
+Add runtime-backed request and result values for production-runtime replay of
+scratch migration output.
+
+## Design
+
+The request names the graph id, runtime writer id, scratch ref, and expected
+scratch head. The result records pass/fail status, witness text, replayed
+operation count, and fatal migration notices.
+
+These nouns do not read Git and do not open runtime state. They are the pure
+evidence boundary that the provider in slice 68 will fill.
+
+## Acceptance Criteria
+
+- Constructors validate runtime request and result envelopes.
+- Passing replay results cannot carry fatal errors.
+- Failing replay results must carry fatal errors.
+- `allowsFinalization()` is true only for passed replay results.
+
+## Test Plan
+
+Unit coverage exercises happy path, failure path, malformed envelopes, invalid
+scratch refs, invalid counts, and mismatched status/fatal-error combinations.

docs/design/0216-v18-production-runtime-scratch-replay-provider/v18-production-runtime-scratch-replay-provider.md

@@ -0,0 +1,46 @@
+---
+cycle: 0216
+task_id: V18_production_runtime_scratch_replay_provider
+status: Complete
+sponsors:
+  human: James
+  agent: Codex
+started_at: 2026-05-24
+completed_at: 2026-05-24
+release_home: v18.0.0
+bearing_task: 68
+---
+
+# V18 Production-Runtime Scratch Replay Provider
+
+## Hill
+
+Implement adapter-level proof that scratch migration operations can be replayed
+through the normal git-warp graph runtime and mapped into finalization
+conformance evidence.
+
+## Design
+
+The provider reads scratch migration operation records from the source
+repository, verifies the scratch ref still points at the expected head, opens an
+isolated normal git-warp runtime, applies the scratch operations through the
+runtime patch surface, materializes the runtime product, and returns runtime
+replay evidence.
+
+The provider maps replay evidence into the existing finalization conformance
+result type so command finalization can later switch from operation-history
+readback to production-runtime replay without changing the safety gate.
+
+## Acceptance Criteria
+
+- Passing replay reports the production-runtime witness and operation count.
+- Stale scratch heads fail before replay.
+- Malformed operation targets fail closed with structured fatal notices.
+- Source live refs are not updated.
+
+## Test Plan
+
+Unit tests write scratch history in a temporary Git repository, replay it
+through an isolated runtime repository, assert passing runtime replay, assert
+finalization-conformance mapping, and assert closed failures for scratch-head
+drift and invalid targets.

docs/design/0217-v18-v17-public-read-legacy-reading/v18-v17-public-read-legacy-reading.md

@@ -0,0 +1,47 @@
+---
+cycle: 0217
+task_id: V18_v17_public_read_legacy_reading
+status: Complete
+sponsors:
+  human: James
+  agent: Codex
+started_at: 2026-05-24
+completed_at: 2026-05-24
+release_home: v18.0.0
+bearing_task: 69
+---
+
+# V18 V17 Public-Read Legacy Reading
+
+## Hill
+
+Construct the legacy side of genesis equivalence from a restored v17 fixture
+repository, with restored-ref verification immediately before the reading is
+used.
+
+## Design
+
+The builder is an adapter-level helper for wet-run migration tests. It accepts
+the restored repository path and validated v17 fixture manifest, verifies each
+writer ref still points at the manifest head with the expected patch count, and
+then projects the manifest's operator-visible public facts into the existing
+`GenesisEquivalenceReading` model.
+
+The restored Git bundle remains the persisted evidence. The manifest remains
+the public-read contract for the fixture because the compact v17 fixture patch
+payloads are not a v18 runtime state format.
+
+## Acceptance Criteria
+
+- A restored fixture produces deterministic legacy facts for node, edge,
+  property, content, removal, and multi-writer coverage.
+- Ref-head drift after restore blocks reading construction.
+- Patch-count drift blocks reading construction.
+- Empty repository paths fail before Git commands run.
+
+## Test Plan
+
+Unit tests restore the canonical v17 fixture into temporary repositories,
+construct the legacy reading, assert deterministic public facts and boundaries,
+mutate a restored writer ref to prove drift is rejected, and validate path
+guarding.

docs/design/0218-v18-scratch-public-read-reading/v18-scratch-public-read-reading.md

@@ -0,0 +1,47 @@
+---
+cycle: 0218
+task_id: V18_scratch_public_read_reading
+status: Complete
+sponsors:
+  human: James
+  agent: Codex
+started_at: 2026-05-24
+completed_at: 2026-05-24
+release_home: v18.0.0
+bearing_task: 70
+---
+
+# V18 Scratch Public-Read Reading
+
+## Hill
+
+Construct the migrated side of genesis equivalence from materialized
+production-runtime state after scratch replay, rather than from the scratch
+operation log alone.
+
+## Design
+
+The scratch public-read builder verifies the scratch ref head, replays scratch
+operation commits through the shared production-runtime replay core, materializes
+an immutable runtime snapshot, and projects visible nodes, edges, scalar node
+properties, and node content attachments into `GenesisEquivalenceReading` facts.
+
+The replay core is factored into a shared script module so finalization
+conformance and scratch public-read construction exercise the same parser,
+operation ordering, patch commit path, and materialization path.
+
+## Acceptance Criteria
+
+- Node and edge facts come from materialized runtime visibility.
+- Property facts come from decoded public snapshot property keys and scalar
+  values.
+- Content attachment facts come from materialized `_content` registers while
+  `_content.mime` and `_content.size` remain metadata, not equivalence facts.
+- Scratch-head drift blocks readback before replay.
+
+## Test Plan
+
+Unit tests write scratch history, replay it through the public-read builder,
+assert deterministic node, edge, and property facts, assert content attachment
+projection from materialized runtime state, and assert closed failure on
+scratch-head drift.

docs/design/0219-v18-v17-fixture-wet-run-harness/v18-v17-fixture-wet-run-harness.md

@@ -0,0 +1,46 @@
+---
+cycle: 0219
+task_id: V18_v17_fixture_wet_run_harness
+status: Complete
+sponsors:
+  human: James
+  agent: Codex
+started_at: 2026-05-24
+completed_at: 2026-05-24
+release_home: v18.0.0
+bearing_task: 71
+---
+
+# V18 V17 Fixture Wet-Run Harness
+
+## Hill
+
+Run the v18 graph-model migration path against a restored v17 fixture
+repository without promoting scratch history to live refs.
+
+## Design
+
+The harness restores the canonical v17 fixture into an isolated repository,
+collects real source inventory from restored writer refs, builds a dry-run
+request from manifest-visible public facts, writes scratch migration history,
+builds legacy and scratch readings through the new public-read builders, and
+runs production-runtime replay conformance as separate evidence.
+
+The harness intentionally leaves finalization disabled. Its current job is to
+exercise the wet path and expose equivalence gaps with concrete evidence, not
+to promote scratch refs.
+
+## Acceptance Criteria
+
+- The canonical fixture restores before any migration work begins.
+- Dry-run planning and lowering pass against restored v17 refs.
+- Scratch history is written in the restored repository.
+- Production-runtime replay passes against the scratch result.
+- Public-read equivalence gaps are explicit in the command result.
+
+## Test Plan
+
+Unit tests run the harness against the canonical fixture, assert restore,
+planning, lowering, scratch writing, and production-runtime replay success,
+assert that finalization is skipped, and assert the current public-read
+equivalence gap as a tracked wet-run signal.