diff --git a/.changeset/lazy-radios-obey.md b/.changeset/lazy-radios-obey.md
new file mode 100644
index 0000000..f10f966
--- /dev/null
+++ b/.changeset/lazy-radios-obey.md
@@ -0,0 +1,5 @@
+---
+"stack-effect": patch
+---
+
+Reject stale scaffolding plans before previewing or applying repository changes.
diff --git a/.okf/architecture/index.md b/.okf/architecture/index.md
index 0d80ce3..1af1729 100644
--- a/.okf/architecture/index.md
+++ b/.okf/architecture/index.md
@@ -1,5 +1,6 @@
 # Architecture
 
 - [Scaffold lifecycle](scaffold-lifecycle.md) describes service ownership, planning, Apply, previews, and Finalize.
+- [Repository state authority](plan-apply-repository-state.md) records the implemented Plan to Apply state contract.
 - [Catalog architecture](catalog.md) describes definitions, lookup, and contributions.
 - [Catalog ID naming](catalog-id-semantics.md) records human-facing naming conventions.
diff --git a/.okf/architecture/plan-apply-repository-state.md b/.okf/architecture/plan-apply-repository-state.md
new file mode 100644
index 0000000..8ab00df
--- /dev/null
+++ b/.okf/architecture/plan-apply-repository-state.md
@@ -0,0 +1,73 @@
+---
+type: Decision
+title: Repository state authority for Plan and Apply
+description: Agreed state, freshness, and publication rules for the Plan to Apply handoff.
+status: stable
+sources:
+  - id: plan
+    resource: ../../packages/domain/src/Plan.ts
+    title: Plan contract
+  - id: apply
+    resource: ../../packages/domain/src/Apply.ts
+    title: Apply contract
+  - id: capture
+    resource: ../../packages/scaffold/src/service/plan/RepoSnapshotService.ts
+    title: Repository text capture
+  - id: baseline
+    resource: ../../packages/scaffold/src/service/plan/RepositoryStateService.ts
+    title: Repository baseline and freshness checks
+  - id: planning
+    resource: ../../packages/scaffold/src/service/plan/PlanService.ts
+    title: Plan construction
+  - id: execution
+    resource: ../../packages/scaffold/src/service/apply/ApplyService.ts
+    title: Apply behavior
+  - id: writing
+    resource: ../../packages/scaffold/src/service/apply/WriteEngine.ts
+    title: Host writes
+generated: { by: codex, at: "2026-09-27T09:22:00+00:00" }
+---
+
+# Repository state authority for Plan and Apply
+
+Status: Implemented for Plan, preview, and Apply.
+
+## Problem
+
+Without a repository baseline, Apply could read newer contents when composing a file or overwrite a file that changed after planning. Preview could show a different host state from the one Plan classified. See the [scaffold lifecycle](scaffold-lifecycle.md "describes implemented behavior").
+
+`Plan.baseline` now stores the canonical root and the state of inspected paths. `RepositoryStateService` fingerprints existing text files and compares their current state with the baseline. `PlanService` checks the capture again before returning. Apply and both preview paths check the baseline before reading or writing. Apply checks each target and its ancestors again before writing. A stale error reports changed paths and, after partial publication, the paths already written. File preview performs its publication step in a private memory filesystem after checking the source repository.
+
+## Decision
+
+### Bind Plan to its repository and captured state
+
+- A host Plan belongs to one canonical repository root. An alias resolving to that root is valid; another root is invalid even when its relevant files match. Planning must also work before the root exists, using the canonical existing parent and intended path to identify it.
+- Plan records the type of every path planning inspected, including missing paths, ancestors, unchanged outcomes, and paths later skipped by an Apply decision. Existing text files use cryptographic content fingerprints. The serializable Plan does not contain copies of existing user files.
+- Explicit planning paths remain in scope even when `.gitignore` matches them. Timestamps and permissions alone do not make a Plan stale. A file changed and restored before validation is acceptable when its checked type and contents match the recorded state.
+- A symlink within the relevant paths, a non-text file, or a special entry makes planning fail clearly. A symlink used only as an alias to the repository root is resolved to the canonical root.
+
+### Reject drift before preview or publication
+
+- Planning rechecks its capture before returning a Plan. This detects a change observed during capture; it does not make the host filesystem transactional.
+- Ordinary dry-run, file preview, and Apply reject a stale Plan and require replanning. They must not silently recompose from changed host contents. A Plan is stale after its successful Apply changes the repository.
+- Before the first Apply write, compare every captured path with the current repository. Report every detected difference by path and change kind, without file contents. Detected preflight drift causes no Apply writes.
+- Recheck each path before its write. If a later check detects drift, stop remaining writes, preserve the changed file, and return a typed stale error with the partial Apply result. The CLI should state what was already written and tell the user to replan.
+
+### Keep host publication guarded
+
+Apply's writer owns host publication and baseline checks. A private virtual workspace may hold the selected state during one workflow, while Plan keeps the serializable baseline. A broad tree export cannot replace the guarded writer. Shared workspace creation, seeding, and result capture are a separate design step described in the [staged workspace research](../research/staged-workspace.md "builds on this decision").
+
+## Limits
+
+The final check and the actual write are separate operations. Another process can change a file between them. Writes also remain per file, so an execution failure can leave a partial result. This decision does not promise a repository-wide transaction.
+
+Configuration written before Plan and commands run after Apply have their own lifecycle contracts. The repository state rule here covers Plan, preview, and Apply, not those separate actions.
+
+## Evidence required for implementation
+
+- Modify, delete, or create a relevant path after planning. Preview and Apply must reject the stale Plan; preflight must leave the host unchanged. Cover composed and authoritative outcomes, missing paths, ancestors, unchanged paths, and skipped conflicts.
+- Apply the same Plan through a canonical alias and try it against an unrelated root with identical relevant contents. Preserve greenfield planning for a root that does not exist yet.
+- Preview an incremental add, edit a host file, then attempt Apply. The host edit must survive. A file restored to its captured state must be accepted.
+- Change a later path after preflight but before its write. Apply must stop, preserve that path, report previous writes, and avoid subsequent writes.
+- Reject relevant symlinks, non-text files, and special entries during planning. Verify that Plan and stale errors do not expose original file contents.
diff --git a/.okf/architecture/scaffold-lifecycle.md b/.okf/architecture/scaffold-lifecycle.md
index 7c399dd..a0b626b 100644
--- a/.okf/architecture/scaffold-lifecycle.md
+++ b/.okf/architecture/scaffold-lifecycle.md
@@ -26,24 +26,24 @@ sources:
     resource: ../../packages/scaffold/src/index.ts
   - id: finalize
     resource: ../../packages/scaffold/src/service/finalize/FinalizeService.ts
-generated: { by: codex, at: "2026-09-22T17:40:50+00:00" }
+generated: { by: codex, at: "2026-09-27T09:22:00+00:00" }
 ---
 
 # Scaffold lifecycle
 
 Selection records user intent. Blueprint resolves dependencies. Plan describes repository-aware outcomes and conflicts. Apply adds explicit decisions only for conflicted paths. VFS state does not replace these domain values.
 
-Plan reads relevant paths and ancestors through `RepoSnapshotService`. This is a selective text view, not a complete VFS snapshot. Plan retains outcomes rather than the full captured baseline.
+Plan reads relevant paths, ancestors, and the root through `RepoSnapshotService`. This is a selective text view, not a complete VFS snapshot. Plan retains outcomes and a serializable baseline with the canonical root, path types, and SHA-256 fingerprints of existing text files. It does not retain existing file contents.
 
-Apply prepares composition before writing. For modified composed files, it re-reads current contents. Individual writes validate path state and use temporary-file rename; failures are collected while later writes continue. This does not provide a repository-wide transaction.
+Apply checks every baseline path before preparing composition or writing. For modified composed files, it re-reads contents after that check. Each write checks its target and ancestors again, then uses a temporary-file rename. A later stale check stops remaining writes and reports the partial result. Other execution failures are collected while later writes continue. This does not provide a repository-wide transaction.
 
-`ApplyPreviewService` copies changed, non-skipped paths into a fresh `MemoryFileSystem`, runs actual Apply, and returns successful changed files. `RecipePreviewService` plans in another memory filesystem and appends configuration to its result separately. Neither changed-file list claims to contain a complete repository.
+`ApplyPreviewService` checks the host baseline, copies every baseline path into a fresh `MemoryFileSystem`, checks the host baseline again, and runs guarded Apply against that private filesystem. It returns successful changed files. `RecipePreviewService` plans in another memory filesystem and appends configuration to its result separately. Neither changed-file list claims to contain a complete repository.
 
-Private previews use VFS `makeCrypto`, which provides reproducible identity generation without a platform Crypto dependency. These volume identities are not security credentials. The public VFS `make` and `layer` APIs require an explicitly supplied Crypto service.
+Private previews use VFS `make` with an explicitly supplied Crypto service. Volume identities are not security credentials.
 
-Ordinary dry-run prepares actions without the same virtual write execution. Finalize commands use a process spawner, and the CLI can proceed into Finalize handling after reporting failed Apply paths.
+Ordinary dry-run checks the baseline and prepares actions without the same virtual write execution. Finalize commands use a process spawner, and the CLI can proceed into Finalize handling after reporting failed Apply paths.
 
-The [staged workspace research](../research/staged-workspace.md "addresses consistency gaps") proposes a shared foundation. The [validation research](../research/virtual-validation.md "examines host execution") retains the external-tool boundary.
+The [repository state decision](plan-apply-repository-state.md "defines the implemented handoff") records the freshness rule. The [staged workspace research](../research/staged-workspace.md "addresses consistency gaps") proposes a shared foundation. The [validation research](../research/virtual-validation.md "examines host execution") retains the external-tool boundary.
 
 ## Service ownership
 
diff --git a/.okf/assets/effect-vfs-design-research.html b/.okf/assets/effect-vfs-design-research.html
index 9da2f24..42a55d1 100644
--- a/.okf/assets/effect-vfs-design-research.html
+++ b/.okf/assets/effect-vfs-design-research.html
@@ -298,11 +298,11 @@ <h1 class="display-1">Effect VFS in Stack Effect</h1>
       </div>
     </header>
 
-<nav class="toc" aria-label="On this page"><strong>On this page</strong><a href="#start-with-a-shared-workspace-keep-catalog-intent-explicit">Start with a shared workspace, keep catalog intent explicit</a><a href="#what-exists-today">What exists today</a><a href="#what-vfs-contributes-and-where-it-stops">What VFS contributes, and where it stops</a><a href="#direction-1-make-preview-a-repeatable-staged-operation">Direction 1: make preview a repeatable staged operation</a><a href="#compare-the-options">Compare the options</a><a href="#existing-issues-already-cover-much-of-the-foundation">Existing issues already cover much of the foundation</a><a href="#experiments-that-would-settle-the-design">Experiments that would settle the design</a><a href="#evidence-and-compatibility">Evidence and compatibility</a></nav><section aria-label="Report context"><p>Research review · 22 September 2026 · Discussion input, not an accepted design</p>
+<nav class="toc" aria-label="On this page"><strong>On this page</strong><a href="#start-with-a-shared-workspace-keep-catalog-intent-explicit">Start with a shared workspace, keep catalog intent explicit</a><a href="#what-exists-today">What exists today</a><a href="#what-vfs-contributes-and-where-it-stops">What VFS contributes, and where it stops</a><a href="#direction-1-make-preview-a-repeatable-staged-operation">Direction 1: make preview a repeatable staged operation</a><a href="#compare-the-options">Compare the options</a><a href="#related-repository-knowledge">Related repository knowledge</a><a href="#experiments-that-would-settle-the-design">Experiments that would settle the design</a><a href="#evidence-and-compatibility">Evidence and compatibility</a></nav><section aria-label="Report context"><p>Research review · 22 September 2026 · Discussion input, not an accepted design</p>
 </section><section id="start-with-a-shared-workspace-keep-catalog-intent-explicit"><h2 class="heading-1">Start with a shared workspace, keep catalog intent explicit</h2>
 <p>Effect VFS fits Stack Effect best as a shared place to prepare, inspect, and repeat filesystem changes. Stack Effect already uses it for previews. The next useful step is to make the captured repository state and candidate result consistent across planning, decisions, and preview.</p>
 <p>For the catalog, prefer immutable snapshots of selected generated recipes, with declarative modules remaining authoritative. An overlay is a private branch of one filesystem snapshot. It does not merge independently generated modules or resolve JSON and TypeScript conflicts. <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyPreviewService.ts#L31-L175">preview: ApplyPreviewService.ts L31–175</a> <a href="https://github.com/lloydrichards/effect-virtual-fs/blob/e9df27fcb565d189bbc501500cc3267561b23533/packages/core/src/VirtualFileSystem.ts#L1973-L2035">overlay: VirtualFileSystem.ts L1973–2035</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/domain/src/Catalog.ts#L126-L223">domain: Catalog.ts L126–223</a></p>
-<p>This report recommends exploring these directions, not replacing Selection, Blueprint, Plan, or Apply. No issues or OKF records have been created. The final sections identify questions and evidence that can support that later work.</p>
+<p>This report recommends exploring these directions, not replacing Selection, Blueprint, Plan, or Apply. The repository state decision and focused research concepts record the current direction.</p>
 </section><section id="what-exists-today"><h2 class="heading-1">What exists today</h2>
 <p>Selection expresses user intent. Blueprint resolves dependencies. Plan assesses proposed changes against repository contents. Apply combines those outcomes with explicit conflict decisions and executes them. Finalize runs commands derived from the Blueprint and configuration. These boundaries remain useful with a virtual filesystem. <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/plan/PlanService.ts#L44-L164">plan: PlanService.ts L44–164</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyService.ts#L268-L400">apply: ApplyService.ts L268–400</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/finalize/FinalizeService.ts#L107-L212">finalize: FinalizeService.ts L107–212</a></p>
 <p>The current filesystem integration has two layers:</p>
@@ -378,12 +378,7 @@ <h1 class="display-1">Effect VFS in Stack Effect</h1>
 <p>The diagram describes a proposal. VFS supplies the private candidate workspace. Stack Effect still owns the Plan, decisions, host checks, publication, and Finalize policy.</p>
 <p>A bounded first version can capture only planned paths and the ancestors needed to reproduce obstructions. Its result must state that scope. A consumer needing a complete tree must seed and capture a complete supported tree rather than treat a changed-file list as one. Decide how to represent bytes, symlinks, modes, directories, and exclusions before broadening beyond the current text-file workflow. <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/plan/RepoSnapshotService.ts#L19-L88">reads: RepoSnapshotService.ts L19–88</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyPreviewService.ts#L31-L175">preview: ApplyPreviewService.ts L31–175</a></p>
 <p>Conflict experiments then become repeatable. Start two candidates from the same baseline, apply skip in one and override in the other, and compare their resulting files. Replacing either candidate leaves the baseline intact. The JSON and TypeScript composers still decide what each accepted action means. <a href="https://github.com/lloydrichards/effect-virtual-fs/blob/e9df27fcb565d189bbc501500cc3267561b23533/packages/core/src/VirtualFileSystem.ts#L1973-L2035">overlay: VirtualFileSystem.ts L1973–2035</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyService.ts#L268-L400">apply: ApplyService.ts L268–400</a></p>
-<p>The public behavior decision is <strong>what to do when the host changes after review</strong>:</p>
-<ul>
-<li>Require a new Plan and review. This is the clearest initial contract.</li>
-<li>Recompose against the changed host and show a new preview. This can preserve unrelated edits, but the new bytes need another review.</li>
-</ul>
-<p>In either policy, publish previously reviewed bytes only when the relevant baseline preconditions still hold. There is still a check-to-write race unless the publication design addresses it. A content hash check alone does not create a host transaction. Wrong-repository detection, newly created paths, deleted files, ancestor changes, and partial publication all need stated outcomes. Existing write behavior should change only through a deliberate contract decision. <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/WriteEngine.ts#L44-L201">write: WriteEngine.ts L44–201</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyService.ts#L268-L400">apply: ApplyService.ts L268–400</a></p>
+<p>The <a href="../architecture/plan-apply-repository-state.md">repository state decision</a> now requires a new Plan and review when relevant host state changes. It also defines wrong-root detection, newly created paths, deleted files, ancestor changes, and partial publication. A content fingerprint check alone does not create a host transaction. <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/WriteEngine.ts#L44-L201">write: WriteEngine.ts L44–201</a></p>
 </section><section id="direction-2-use-snapshots-for-generated-artifacts"><h2 class="heading-1">Direction 2: use snapshots for generated artifacts</h2>
 <p><strong>Recommended independent discovery track.</strong> Store snapshots of concrete recipes or validated reference projects. Create live volumes only when opening or modifying those artifacts. This avoids keeping a live volume for every catalog variation.</p>
 <p>A generated artifact can support browser previews, reproductions, example downloads, or a cache. The first consumer should decide the format&#39;s completeness and lifecycle stage. A pre-Finalize source tree has a much smaller scope than a project with installed dependencies, generated lockfiles, and formatter output. Current previews synthesize configuration separately; current catalog workspace generation also runs host Finalize commands after applying files. <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/recipe/RecipePreviewService.ts#L49-L117">recipe: RecipePreviewService.ts L49–117</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/apps/cli/src/commands/catalog.ts#L609-L645">authoring: catalog.ts L609–645</a></p>
@@ -455,41 +450,37 @@ <h1 class="display-1">Effect VFS in Stack Effect</h1>
 <p>Injected Effect <code>FileSystem</code> does not redirect <code>node:fs</code>, package managers, native extensions, or spawned commands. The VFS Vite demo uses an explicit plugin with a narrow supported profile. It does not demonstrate arbitrary builds, formatters, or type-checkers working in memory. <a href="https://github.com/lloydrichards/effect-virtual-fs/blob/e9df27fcb565d189bbc501500cc3267561b23533/apps/docs/app/content/guides/overlay-filesystems.mdx#L75-L136">guide: overlay-filesystems.mdx L75–136</a> <a href="https://github.com/lloydrichards/effect-virtual-fs/blob/e9df27fcb565d189bbc501500cc3267561b23533/apps/virtual-build/src/VirtualBuild.ts#L13-L97">virtual-build: VirtualBuild.ts L13–97</a></p>
 <p>For generated-project validation, a practical first option is to export supported files to a temporary real directory, run declared commands, and clean it up. If command output becomes part of the artifact, import and capture it under a defined policy. Do not describe that as process isolation or rollback of external effects.</p>
 <p>The CLI currently continues into Finalize handling after reporting failed Apply paths. Configuration writing is also separate. The research exposes decisions about whether failures should stop Finalize and which generated configuration belongs in staged output. They are lifecycle questions, not responsibilities to add to the low-level workspace facility. <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/apps/cli/src/service/ScaffoldPipeline.ts#L184-L348">pipeline: ScaffoldPipeline.ts L184–348</a> <a href="https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/apps/cli/src/commands/init.ts#L330-L350">config: init.ts L330–350</a></p>
-</section><section id="existing-issues-already-cover-much-of-the-foundation"><h2 class="heading-1">Existing issues already cover much of the foundation</h2>
-<p>The following issues were checked live on 22 September 2026 and were all open. Their state may change after this report.</p>
-<div class="table-scroll" tabindex="0" role="region" aria-label="Comparison table"><table><caption>Existing roadmap issues</caption>
+</section><section id="related-repository-knowledge"><h2 class="heading-1">Related repository knowledge</h2>
+<p>The focused concepts record accepted behavior and the remaining research directions.</p>
+<div class="table-scroll" tabindex="0" role="region" aria-label="Comparison table"><table><caption>Related repository concepts</caption>
 <thead>
 <tr>
-<th scope="col">Existing issue</th>
+<th scope="col">Concept</th>
 <th scope="col">Relationship to this research</th>
 </tr>
 </thead>
 <tbody><tr>
-<td><a href="https://github.com/lloydrichards/stack-effect/issues/175">#175: repository state represented by Plan</a></td>
-<td>Owns drift, repository authority, and preview consistency</td>
-</tr>
-<tr>
-<td><a href="https://github.com/lloydrichards/stack-effect/issues/250">#250: reusable in-memory workspace</a></td>
-<td>Owns setup, seeding, binding and capture; blocked by #175</td>
+<td><a href="../architecture/plan-apply-repository-state.md">Repository state authority</a></td>
+<td>Accepted drift, repository identity, and preview contract</td>
 </tr>
 <tr>
-<td><a href="https://github.com/lloydrichards/stack-effect/issues/253">#253: materialized catalog combination tests</a></td>
-<td>Exercises combinations and incremental add after #250</td>
+<td><a href="../research/staged-workspace.md">Staged workspace lifecycle</a></td>
+<td>Proposed setup, seeding, binding, and capture after state authority</td>
 </tr>
 <tr>
-<td><a href="https://github.com/lloydrichards/stack-effect/issues/251">#251: in-memory Vite validation</a></td>
-<td>Narrow validation experiment after #250; keeps host validation</td>
+<td><a href="../research/virtual-validation.md">Virtual validation</a></td>
+<td>Candidate structural tests and a bounded build experiment</td>
 </tr>
 <tr>
-<td><a href="https://github.com/lloydrichards/stack-effect/issues/252">#252: portable generated-workspace artifact</a></td>
-<td>Independent discovery; needs a concrete consumer and owned versioned schema</td>
+<td><a href="../research/generated-artifacts.md">Generated workspace artifacts</a></td>
+<td>Open completeness and compatibility requirements</td>
 </tr>
 <tr>
-<td><a href="https://github.com/lloydrichards/stack-effect/issues/249">#249: Community Catalog foundation</a></td>
-<td>Trusted additive declarative fragments; distribution and fragment Finalize excluded</td>
+<td><a href="../research/compiled-catalog-profiles.md">Compiled catalog profiles</a></td>
+<td>Relationship between concrete snapshots and declarative fragments</td>
 </tr>
 </tbody></table></div>
-<p>The next issue-writing round should refine and connect these rather than duplicate them. The less-developed question is how compiled artifacts relate to declarative fragments, parametrization, provenance, and upgrade identity.</p>
+<p>The less-developed question is how compiled artifacts relate to declarative fragments, parametrization, provenance, and upgrade identity.</p>
 </section><section id="experiments-that-would-settle-the-design"><h2 class="heading-1">Experiments that would settle the design</h2>
 <ol>
 <li><strong>Workspace parity.</strong> Run one realistic incremental-add scenario against host and VFS. Include existing user fields, a skipped conflict, an ancestor obstruction, and two modules changing one shared file. Compare outcomes and bytes; prove preview leaves the host untouched.</li>
@@ -514,7 +505,7 @@ <h1 class="display-1">Effect VFS in Stack Effect</h1>
 </ul>
 <p>The evidence currently supports extending the existing workspace integration. It does not yet establish a performance case for a registry, arbitrary module overlay composition, or atomic host application.</p>
 </section><section id="evidence-and-compatibility"><h2 class="heading-1">Evidence and compatibility</h2>
-<p>Primary evidence is the local source, tests, and documentation in both maintained repositories, plus live read-only GitHub issue inspection. Historical memory was used to locate existing roadmap work, then issue state and relevant implementation were checked again.</p>
+<p>Primary evidence is the local source, tests, and documentation in both maintained repositories.</p>
 <ul>
 <li>Stack Effect inspected at <code>820a670c80a857f46557875e6ee53c7742dad5cd</code>, initially clean.</li>
 <li>Effect VFS inspected at <code>e9df27fcb565d189bbc501500cc3267561b23533</code>, clean.</li>
diff --git a/.okf/index.md b/.okf/index.md
index f231c0b..b64b11b 100644
--- a/.okf/index.md
+++ b/.okf/index.md
@@ -9,6 +9,6 @@ okf_version: "0.2"
 - [Authoring guides](guides/index.md) explain how to extend the catalog.
 - [Research](research/index.md) records draft VFS directions and their evidence.
 
-Start with the [scaffold lifecycle](architecture/scaffold-lifecycle.md). Research proposals remain drafts until a decision is accepted and implemented. The dated VFS report describes the revision it inspected; use the focused concepts for current guidance.
+Start with the [scaffold lifecycle](architecture/scaffold-lifecycle.md). The [repository state decision](architecture/plan-apply-repository-state.md) describes the implemented Plan to Apply handoff. Other research proposals remain drafts. The dated VFS report describes the revision it inspected; use the focused concepts for current guidance.
 
 Validate with `bunx okf-graph@0.3.0 validate .okf --json`.
diff --git a/.okf/research/compiled-catalog-profiles.md b/.okf/research/compiled-catalog-profiles.md
index 6fd262b..7311e8f 100644
--- a/.okf/research/compiled-catalog-profiles.md
+++ b/.okf/research/compiled-catalog-profiles.md
@@ -4,9 +4,6 @@ title: Compiled catalog profiles
 description: Proposed relationship between declarative catalog fragments and generated snapshot artifacts.
 status: draft
 sources:
-  - id: exploration
-    resource: https://github.com/lloydrichards/stack-effect/issues/254
-    title: Compiled profile and cache identity exploration
   - id: catalog
     resource: ../../packages/domain/src/Catalog.ts
     title: Declarative contribution contracts
@@ -16,13 +13,13 @@ sources:
   - id: inputs
     resource: ../../packages/domain/src/Scaffold.ts
     title: Rendering input dimensions
-  - id: community
-    resource: https://github.com/lloydrichards/stack-effect/issues/249
-    title: Community Catalog foundation
+  - id: catalog-architecture
+    resource: ../architecture/catalog.md
+    title: Catalog composition boundary
   - id: report
     resource: effect-vfs-review.md
     title: Catalog alternatives and evidence
-generated: { by: codex, at: "2026-09-22T19:00:00+02:00" }
+generated: { by: codex, at: "2026-09-27T09:07:55+00:00" }
 ---
 
 # Compiled catalog profiles
@@ -35,7 +32,7 @@ Prefer named profiles and generation on demand over every possible variation. Pr
 
 Investigate whether one concrete consumer benefits from compiled profiles. Compare generation cost with snapshot decode cost, payload size, and memory. Include catalog identity, normalized inputs, composer version, and generation stage in the proposed cache identity. Preserve multiple contributors per path.
 
-This extends the [artifact discussion](generated-artifacts.md "depends on completeness") and #249 without adding remote discovery, executable fragment hooks, or a marketplace to the initial fragment contract.
+This extends the [artifact discussion](generated-artifacts.md "depends on completeness") and preserves the [declarative catalog boundary](../architecture/catalog.md "keeps definitions authoritative"). Remote discovery, executable fragment hooks, and a marketplace are outside the initial fragment contract.
 
 ## Open outcome
 
diff --git a/.okf/research/effect-vfs-review.md b/.okf/research/effect-vfs-review.md
index d6ce7ce..7ef8f4d 100644
--- a/.okf/research/effect-vfs-review.md
+++ b/.okf/research/effect-vfs-review.md
@@ -8,7 +8,7 @@ sources:
     resource: ../assets/effect-vfs-design-research.html
   - id: source-1
     resource: https://github.com/lloydrichards/effect-virtual-fs/tree/e9df27fcb565d189bbc501500cc3267561b23533
-generated: { by: codex, at: "2026-09-22T17:40:50+00:00" }
+generated: { by: codex, at: "2026-09-27T09:07:55+00:00" }
 ---
 
 # Effect VFS in Stack Effect: design directions
@@ -21,7 +21,7 @@ Effect VFS fits Stack Effect best as a shared place to prepare, inspect, and rep
 
 For the catalog, prefer immutable snapshots of selected generated recipes, with declarative modules remaining authoritative. An overlay is a private branch of one filesystem snapshot. It does not merge independently generated modules or resolve JSON and TypeScript conflicts. [preview: ApplyPreviewService.ts L31–175](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyPreviewService.ts#L31-L175) [overlay: VirtualFileSystem.ts L1973–2035](https://github.com/lloydrichards/effect-virtual-fs/blob/e9df27fcb565d189bbc501500cc3267561b23533/packages/core/src/VirtualFileSystem.ts#L1973-L2035) [domain: Catalog.ts L126–223](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/domain/src/Catalog.ts#L126-L223)
 
-This report recommends exploring these directions, not replacing Selection, Blueprint, Plan, or Apply. The report records the initial review. Follow the [staged workspace research](staged-workspace.md "tracks the next design") for the concepts and issue links created afterward.
+This report recommends exploring these directions, not replacing Selection, Blueprint, Plan, or Apply. The report records the initial review. Follow the [repository state decision](../architecture/plan-apply-repository-state.md "records accepted behavior") and [staged workspace research](staged-workspace.md "tracks the next design") for current direction.
 
 ## What exists today
 
@@ -87,12 +87,7 @@ A bounded first version can capture only planned paths and the ancestors needed
 
 Conflict experiments then become repeatable. Start two candidates from the same baseline, apply skip in one and override in the other, and compare their resulting files. Replacing either candidate leaves the baseline intact. The JSON and TypeScript composers still decide what each accepted action means. [overlay: VirtualFileSystem.ts L1973–2035](https://github.com/lloydrichards/effect-virtual-fs/blob/e9df27fcb565d189bbc501500cc3267561b23533/packages/core/src/VirtualFileSystem.ts#L1973-L2035) [apply: ApplyService.ts L268–400](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyService.ts#L268-L400)
 
-The public behavior decision is **what to do when the host changes after review**:
-
-- Require a new Plan and review. This is the clearest initial contract.
-- Recompose against the changed host and show a new preview. This can preserve unrelated edits, but the new bytes need another review.
-
-In either policy, publish previously reviewed bytes only when the relevant baseline preconditions still hold. There is still a check-to-write race unless the publication design addresses it. A content hash check alone does not create a host transaction. Wrong-repository detection, newly created paths, deleted files, ancestor changes, and partial publication all need stated outcomes. Existing write behavior should change only through a deliberate contract decision. [write: WriteEngine.ts L44–201](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/WriteEngine.ts#L44-L201) [apply: ApplyService.ts L268–400](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/ApplyService.ts#L268-L400)
+The [repository state decision](../architecture/plan-apply-repository-state.md "sets the accepted drift rule") now requires a new Plan and review when relevant host state changes. It also defines wrong-root detection, newly created paths, deleted files, ancestor changes, and partial publication. A content fingerprint check alone does not create a host transaction. [write: WriteEngine.ts L44–201](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/packages/scaffold/src/service/apply/WriteEngine.ts#L44-L201)
 
 ## Direction 2: use snapshots for generated artifacts
 
@@ -144,20 +139,17 @@ For generated-project validation, a practical first option is to export supporte
 
 The CLI currently continues into Finalize handling after reporting failed Apply paths. Configuration writing is also separate. The research exposes decisions about whether failures should stop Finalize and which generated configuration belongs in staged output. They are lifecycle questions, not responsibilities to add to the low-level workspace facility. [pipeline: ScaffoldPipeline.ts L184–348](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/apps/cli/src/service/ScaffoldPipeline.ts#L184-L348) [config: init.ts L330–350](https://github.com/lloydrichards/stack-effect/blob/b72a69a6deb0b5ad85c68b86ae75a6b7ef7379a3/apps/cli/src/commands/init.ts#L330-L350)
 
-## Existing issues already cover much of the foundation
-
-The following issues were checked live on 22 September 2026 and were all open. Their state may change after this report.
+## Related repository knowledge
 
-| Existing issue | Relationship to this research |
+| Concept | Relationship to this research |
 | --- | --- |
-| [#175: repository state represented by Plan](https://github.com/lloydrichards/stack-effect/issues/175) | Owns drift, repository authority, and preview consistency |
-| [#250: reusable in-memory workspace](https://github.com/lloydrichards/stack-effect/issues/250) | Owns setup, seeding, binding and capture; blocked by #175 |
-| [#253: materialized catalog combination tests](https://github.com/lloydrichards/stack-effect/issues/253) | Exercises combinations and incremental add after #250 |
-| [#251: in-memory Vite validation](https://github.com/lloydrichards/stack-effect/issues/251) | Narrow validation experiment after #250; keeps host validation |
-| [#252: portable generated-workspace artifact](https://github.com/lloydrichards/stack-effect/issues/252) | Independent discovery; needs a concrete consumer and owned versioned schema |
-| [#249: Community Catalog foundation](https://github.com/lloydrichards/stack-effect/issues/249) | Trusted additive declarative fragments; distribution and fragment Finalize excluded |
+| [Repository state authority](../architecture/plan-apply-repository-state.md) | Accepted drift, repository identity, and preview contract |
+| [Staged workspace lifecycle](staged-workspace.md) | Proposed setup, seeding, binding, and capture after state authority |
+| [Virtual validation](virtual-validation.md) | Candidate structural tests and a bounded build experiment |
+| [Generated workspace artifacts](generated-artifacts.md) | Open completeness and compatibility requirements |
+| [Compiled catalog profiles](compiled-catalog-profiles.md) | Relationship between concrete snapshots and declarative fragments |
 
-The next issue-writing round should refine and connect these rather than duplicate them. The less-developed question is how compiled artifacts relate to declarative fragments, parametrization, provenance, and upgrade identity.
+The less-developed question is how compiled artifacts relate to declarative fragments, parametrization, provenance, and upgrade identity.
 
 ## Experiments that would settle the design
 
@@ -188,7 +180,7 @@ The evidence currently supports extending the existing workspace integration. It
 
 ## Evidence and compatibility
 
-Primary evidence is the local source, tests, and documentation in both maintained repositories, plus live read-only GitHub issue inspection. Historical memory was used to locate existing roadmap work, then issue state and relevant implementation were checked again.
+Primary evidence is the local source, tests, and documentation in both maintained repositories.
 
 - Stack Effect inspected at `820a670c80a857f46557875e6ee53c7742dad5cd`, initially clean.
 - Effect VFS inspected at `e9df27fcb565d189bbc501500cc3267561b23533`, clean.
diff --git a/.okf/research/generated-artifacts.md b/.okf/research/generated-artifacts.md
index ee6d9d1..5352fc0 100644
--- a/.okf/research/generated-artifacts.md
+++ b/.okf/research/generated-artifacts.md
@@ -4,9 +4,6 @@ title: Generated workspace artifacts
 description: Open completeness and compatibility requirements for portable generated files.
 status: draft
 sources:
-  - id: issue
-    resource: https://github.com/lloydrichards/stack-effect/issues/252
-    title: Portable artifact discussion
   - id: preview
     resource: ../../packages/scaffold/src/service/apply/ApplyPreviewService.ts
     title: Current changed-file result
diff --git a/.okf/research/oxlint-tsgo-migration.md b/.okf/research/oxlint-tsgo-migration.md
index 1369a49..f87e803 100644
--- a/.okf/research/oxlint-tsgo-migration.md
+++ b/.okf/research/oxlint-tsgo-migration.md
@@ -1,7 +1,29 @@
+---
+type: Research Report
+title: Oxlint and Oxfmt with Effect tsgo
+description: Dated migration rationale and compatibility research for the repository tooling change.
+status: draft
+sources:
+  - id: root
+    resource: ../../package.json
+    title: Current root tooling scripts and dependencies
+  - id: docs
+    resource: ../../apps/docs/package.json
+    title: Docs tooling scripts
+  - id: catalog-modules
+    resource: ../../packages/catalog/src/registry/modules/init.ts
+    title: Generated lint and format module definitions
+  - id: catalog-content
+    resource: ../../packages/catalog/src/registry/content/init.ts
+    title: Generated lint and format content
+---
+
 # Oxlint and Oxfmt with Effect tsgo: migration research
 
 Status: implemented in the root repository, 2026-09-27. Generated project choices remain separate.
 
+This is the research captured before migration. Version ranges, commands, and the "Current repo facts" section describe that earlier checkout and need rechecking before reuse.
+
 ## Recommended shape
 
 Use Oxlint for lint diagnostics and Oxfmt for formatting. Both belong to Oxc and use its VS Code extension, although they remain separate binaries and config files. The installed `@effect/tsgo@0.46.1` lists TypeScript `7.0.2`, Oxlint `1.82.0`–`1.85.0`, and `oxlint-tsgolint` `7.0.2001`–`7.0.2003` as supported. Pin compatible Oxlint and tsgolint versions, add Oxfmt, then change the root prepare script from `effect-tsgo patch --typescript --no-oxlint` to `effect-tsgo patch --typescript --oxlint`. The patch command checks versions before changing integrations. [Effect setup](https://github.com/Effect-TS/tsgo/blob/main/docs/README.md); [package README](https://github.com/Effect-TS/tsgo/blob/main/_packages/tsgo/README.md); [Oxfmt editor setup](https://oxc.rs/docs/guide/usage/formatter/editors).
@@ -34,6 +56,6 @@ For VS Code, recommend `oxc.oxc-vscode` and make it the default formatter. The e
 
 Root `lint` is `biome lint .`; `format` and `format:check` use `biome check`; `apps/docs` also has `biome lint .`. Root prepare explicitly excludes Oxlint. The repo already uses TypeScript `7.0.2`, `@effect/tsgo@0.46.1`, and VS Code tsgo. These observations are from the current checkout's `package.json`, `apps/docs/package.json`, `biome.jsonc`, `.vscode/settings.json`, and installed `node_modules/@effect/tsgo/README.md`.
 
-The local CLI confirms the intended tool split. I ran `stack-effect create oxlint-research --target package/domain:domain-api-contracts --typescript 7 --monorepo turbo --lint oxlint --format oxfmt --yes --dry-run --show-files --no-git` against a temporary root, then removed that root. The preview emitted `.oxlintrc.json`, `.oxfmtrc.jsonc`, `lint: oxlint`, `format: oxfmt`, `format:check: oxfmt --check`, `prepare: effect-tsgo patch --oxlint`, and an Oxc editor extension recommendation. It selected `oxfmt@^0.65.0`, `oxlint@1.80.0`, `oxlint-tsgolint@7.0.2001`, and `@effect/tsgo@0.38.0`; these are the catalog's generated-project versions, not the versions already installed in this repository. The installed `@effect/tsgo@0.46.1` supports Oxlint `1.82.0`–`1.85.0`, so do not copy the CLI's Oxlint version into this root migration. [Local catalog definitions](../../packages/catalog/src/registry/modules/init.ts); [local generated content](../../packages/catalog/src/registry/content/init.ts); [package compatibility table](https://github.com/Effect-TS/tsgo/blob/main/_packages/tsgo/README.md).
+The local CLI confirms the intended tool split. I ran `stack-effect create oxlint-research --target package/domain:domain-api-contracts --typescript 7 --monorepo turbo --lint oxlint --format oxfmt --yes --dry-run --show-files --no-git` against a temporary root, then removed that root. The preview emitted `.oxlintrc.json`, `.oxfmtrc.jsonc`, `lint: oxlint`, `format: oxfmt`, `format:check: oxfmt --check`, `prepare: effect-tsgo patch --oxlint`, and an Oxc editor extension recommendation. It selected `oxfmt@^0.65.0`, `oxlint@1.80.0`, `oxlint-tsgolint@7.0.2001`, and `@effect/tsgo@0.38.0`; these are the catalog's generated-project versions, not the versions already installed in this repository. The installed `@effect/tsgo@0.46.1` supports Oxlint `1.82.0`–`1.85.0`, so do not copy the CLI's Oxlint version into this root migration. The local catalog definitions and generated content are listed in the sources above. [Package compatibility table](https://github.com/Effect-TS/tsgo/blob/main/_packages/tsgo/README.md).
 
 Oxlint's VS Code extension runs Oxlint's LSP. Effect tsgo remains the TypeScript language server; the Oxlint patch connects its type-aware lint engine to Effect tsgo. They are two editor integrations serving different diagnostics. To avoid duplicate Effect diagnostics, upstream recommends disabling `@effect/language-service` diagnostics in the tsgo plugin once Oxlint has become the authoritative Effect lint gate. Keep the current type-check gate until that change has been verified. [Effect Oxlint setup](https://github.com/Effect-TS/tsgo/blob/main/docs/README.md); [Effect tsgo README](https://github.com/Effect-TS/tsgo/blob/main/_packages/tsgo/README.md).
diff --git a/.okf/research/staged-workspace.md b/.okf/research/staged-workspace.md
index f47114e..4085b15 100644
--- a/.okf/research/staged-workspace.md
+++ b/.okf/research/staged-workspace.md
@@ -7,16 +7,16 @@ sources:
   - id: report
     resource: effect-vfs-review.md
     title: VFS design research
-  - id: drift
-    resource: https://github.com/lloydrichards/stack-effect/issues/175
-    title: Repository state authority
-  - id: workspace
-    resource: https://github.com/lloydrichards/stack-effect/issues/250
-    title: Reusable in-memory workspace
+  - id: authority
+    resource: ../architecture/plan-apply-repository-state.md
+    title: Accepted repository state authority
+  - id: preview
+    resource: ../../packages/scaffold/src/service/apply/ApplyPreviewService.ts
+    title: Current in-memory preview
   - id: vfs
     resource: https://github.com/lloydrichards/effect-virtual-fs/blob/e9df27fcb565d189bbc501500cc3267561b23533/packages/core/src/VirtualFileSystem.ts
     title: Inspected VFS overlay implementation
-generated: { by: codex, at: "2026-09-22T19:00:00+02:00" }
+generated: { by: codex, at: "2026-09-27T09:07:55+00:00" }
 ---
 
 # Staged workspace lifecycle
@@ -27,7 +27,7 @@ The proposed sequence is to capture supported repository state, build a Plan aga
 
 VFS overlays begin from one immutable snapshot. They allow repeatable decision experiments and cheap disposal of unpublished changes. Replacing an overlay does not redirect existing callers; the owner must replace bindings and release scopes deliberately.
 
-Issue #175 must settle repository authority and drift before #250 consumes that contract. Decide whether host changes require replanning or recomposition followed by another review. Checking baseline hashes alone does not eliminate the race between validation and writing, or provide atomic multi-file publication.
+The [repository state decision](../architecture/plan-apply-repository-state.md "sets the authority contract") requires rejecting stale Plans and replanning. The shared workspace should consume that contract while owning selective setup, seeding, filesystem binding, and result capture. Baseline fingerprints alone do not eliminate the race between validation and writing, or provide atomic multi-file publication.
 
 A bounded capture must reproduce relevant ancestor obstructions and declare what it omits. Keep conflict policy in Apply and host recovery outside VFS. Existing partial-write behavior should change only through an explicit contract decision.
 
diff --git a/.okf/research/virtual-validation.md b/.okf/research/virtual-validation.md
index 66074d7..a5ab1ee 100644
--- a/.okf/research/virtual-validation.md
+++ b/.okf/research/virtual-validation.md
@@ -4,34 +4,28 @@ title: Virtual validation and Finalize
 description: Limits of filesystem injection for generated-project checks and external commands.
 status: draft
 sources:
-  - id: catalog-validation
-    resource: https://github.com/lloydrichards/stack-effect/issues/255
-    title: Generated catalog validation defect
-  - id: vite
-    resource: https://github.com/lloydrichards/stack-effect/issues/251
-    title: Vite validation experiment
-  - id: finalize
-    resource: https://github.com/lloydrichards/stack-effect/issues/179
-    title: Apply-to-Finalize lifecycle
-  - id: tests
-    resource: https://github.com/lloydrichards/stack-effect/issues/253
-    title: Materialized combination tests
+  - id: preview
+    resource: ../../packages/scaffold/src/service/apply/ApplyPreviewService.ts
+    title: Current in-memory preview
+  - id: recipe
+    resource: ../../packages/scaffold/src/service/recipe/RecipePreviewService.ts
+    title: Current recipe preview
   - id: runtime
     resource: ../../packages/scaffold/src/service/finalize/FinalizeService.ts
     title: Finalize command execution
-generated: { by: codex, at: "2026-09-22T19:00:00+02:00" }
+generated: { by: codex, at: "2026-09-27T09:07:55+00:00" }
 ---
 
 # Virtual validation and Finalize
 
 Injected Effect `FileSystem` only redirects consumers of that service. Package managers, `node:fs`, native extensions, and subprocesses need explicit adaptation or a real directory.
 
-Keep #251 to one controlled Vite profile and measure cold time, repeated time, bundle growth, and diagnostic usefulness. An adapter-supported build does not establish general in-memory type-checking or package installation.
+Start any Vite experiment with one controlled profile. Measure cold time, repeated time, bundle growth, and diagnostic usefulness. An adapter-supported build does not establish general in-memory type-checking or package installation.
 
-Use #253 for representative catalog combinations and incremental add through the production pipeline. Rebuild Plan from the first resulting workspace before testing idempotency. Retain host tests for operating-system and external-tool behavior.
+Test representative catalog combinations and incremental add through the production pipeline. Rebuild Plan from the first resulting workspace before testing idempotency. Retain host tests for operating-system and external-tool behavior.
 
-Issue #179 owns which Apply result Finalize acts on, including failed and skipped paths. The workspace facility must not silently decide that policy. A temporary host export is one possible validation mechanism, with cleanup and explicit treatment of tool-generated output.
+The Apply-to-Finalize lifecycle must define which result Finalize acts on, including failed and skipped paths. The workspace facility must not silently decide that policy. A temporary host export is one possible validation mechanism, with cleanup and explicit treatment of tool-generated output.
 
 [Staged workspaces](staged-workspace.md "provides candidate files") supply the input. [Generated artifacts](generated-artifacts.md "records validation stage") must distinguish generated source from post-Finalize state.
 
-The existing host-backed catalog workspace also needs to pass its own checks. [Issue #255](https://github.com/lloydrichards/stack-effect/issues/255) tracks generated chat callback typing failures separately from the future combination harness.
+The existing host-backed catalog workspace still needs its own checks. Its failures should be reported separately from in-memory combination tests.
diff --git a/apps/cli/src/commands/plan.ts b/apps/cli/src/commands/plan.ts
index 2cd2d94..e49420a 100644
--- a/apps/cli/src/commands/plan.ts
+++ b/apps/cli/src/commands/plan.ts
@@ -167,6 +167,7 @@ export const plan = Command.make(
         ),
         Match.when("raw", () =>
           Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))({
+            baseline: planResult.baseline,
             outcomes: planResult.outcomes,
             conflicts: planResult.conflicts,
             summary,
diff --git a/apps/cli/src/service/ScaffoldPipeline.test.ts b/apps/cli/src/service/ScaffoldPipeline.test.ts
index d1f6529..56411d9 100644
--- a/apps/cli/src/service/ScaffoldPipeline.test.ts
+++ b/apps/cli/src/service/ScaffoldPipeline.test.ts
@@ -23,8 +23,13 @@ import {
 } from "./ScaffoldPipeline";
 
 const blueprint = new Blueprint({ nodes: [], edges: [] });
-const plan = new Plan({ outcomes: [], conflicts: [] });
+const baseline = { root: "/tmp/pipeline-app", paths: [] };
+const plan = new Plan({ baseline, outcomes: [], conflicts: [] });
 const conflictPlan = new Plan({
+  baseline: {
+    root: "/tmp/pipeline-app",
+    paths: [{ _tag: "missing", path: "package.json" }],
+  },
   outcomes: [
     {
       _tag: "complete",
diff --git a/packages/domain/src/Apply.test.ts b/packages/domain/src/Apply.test.ts
index 804bd61..9e59a77 100644
--- a/packages/domain/src/Apply.test.ts
+++ b/packages/domain/src/Apply.test.ts
@@ -3,6 +3,7 @@ import {
   ApplyDecision,
   ApplyFailure,
   ApplyResult,
+  StalePlanFailure,
 } from "@repo/domain/Apply";
 import { Plan } from "@repo/domain/Plan";
 import { Schema } from "effect";
@@ -48,6 +49,7 @@ describe("@repo/domain Apply", () => {
   it("sorts apply decisions deterministically", () => {
     const apply = new Apply({
       plan: new Plan({
+        baseline: { root: "/workspace", paths: [] },
         outcomes: [],
         conflicts: [],
       }),
@@ -113,4 +115,21 @@ describe("@repo/domain Apply", () => {
 
     expect(error.reason).toBe("invalidApplyIntent");
   });
+
+  it("decodes stale Plan failures with a partial result and no file contents", () => {
+    const error = Schema.decodeSync(StalePlanFailure)({
+      _tag: "StalePlanFailure",
+      message: "The repository changed after planning",
+      changes: [{ path: "README.md", kind: "modified" }],
+      partialResult: {
+        created: ["package.json"],
+        modified: [],
+        skipped: [],
+        failed: [],
+      },
+    });
+
+    expect(error.changes).toEqual([{ path: "README.md", kind: "modified" }]);
+    expect(error.partialResult.created).toEqual(["package.json"]);
+  });
 });
diff --git a/packages/domain/src/Apply.ts b/packages/domain/src/Apply.ts
index d2d8a33..4f935d9 100644
--- a/packages/domain/src/Apply.ts
+++ b/packages/domain/src/Apply.ts
@@ -78,3 +78,24 @@ export class ApplyResult extends Schema.Class<ApplyResult>("ApplyResult")({
     });
   }
 }
+
+export const StalePlanChange = Schema.Struct({
+  path: Schema.String,
+  kind: Schema.Literals([
+    "created",
+    "deleted",
+    "modified",
+    "typeChanged",
+    "rootChanged",
+  ]),
+});
+
+/** A Plan no longer describes the repository being previewed or written. */
+export class StalePlanFailure extends Schema.TaggedError<StalePlanFailure>()(
+  "StalePlanFailure",
+  {
+    message: Schema.String,
+    changes: Schema.Array(StalePlanChange),
+    partialResult: ApplyResult,
+  },
+) {}
diff --git a/packages/domain/src/Plan.test.ts b/packages/domain/src/Plan.test.ts
index 625d001..79dcf9c 100644
--- a/packages/domain/src/Plan.test.ts
+++ b/packages/domain/src/Plan.test.ts
@@ -3,6 +3,7 @@ import { Schema } from "effect";
 import { describe, expect, it } from "vitest";
 
 describe("@repo/domain Plan", () => {
+  const baseline = { root: "/workspace", paths: [] } as const;
   it("should accept supported classifications and reject unsupported values", () => {
     expect(Schema.decodeSync(PlanEntryClassification)("create")).toBe("create");
     expect(Schema.decodeSync(PlanEntryClassification)("modify")).toBe("modify");
@@ -36,6 +37,13 @@ describe("@repo/domain Plan", () => {
 
   it("should sort outcomes and distinct same-path diagnostics deterministically", () => {
     const plan = new Plan({
+      baseline: {
+        root: "/workspace",
+        paths: [
+          { _tag: "missing", path: "z.txt" },
+          { _tag: "file", path: "a.txt", sha256: "abc" },
+        ],
+      },
       outcomes: [
         {
           _tag: "complete",
@@ -91,6 +99,10 @@ describe("@repo/domain Plan", () => {
       "packages/domain/src/index.ts",
       "packages/domain/tsconfig.json",
     ]);
+    expect(plan.baseline.paths.map((entry) => entry.path)).toEqual([
+      "a.txt",
+      "z.txt",
+    ]);
     expect(plan.conflicts.map((conflict) => conflict.path)).toEqual([
       "packages/domain/src/index.ts",
       "apps/web/src/App.tsx",
@@ -115,10 +127,26 @@ describe("@repo/domain Plan", () => {
     readonly name: string;
     readonly construct: () => Plan;
   }> = [
+    {
+      name: "duplicate baseline paths",
+      construct: () =>
+        new Plan({
+          baseline: {
+            root: "/workspace",
+            paths: [
+              { _tag: "missing", path: "README.md" },
+              { _tag: "directory", path: "README.md" },
+            ],
+          },
+          outcomes: [],
+          conflicts: [],
+        }),
+    },
     {
       name: "duplicate outcome paths",
       construct: () =>
         new Plan({
+          baseline,
           outcomes: [
             {
               _tag: "complete",
@@ -140,6 +168,7 @@ describe("@repo/domain Plan", () => {
       name: "duplicate exact conflict diagnostics",
       construct: () =>
         new Plan({
+          baseline,
           outcomes: [
             {
               _tag: "complete",
@@ -158,6 +187,7 @@ describe("@repo/domain Plan", () => {
       name: "orphan conflict diagnostics",
       construct: () =>
         new Plan({
+          baseline,
           outcomes: [],
           conflicts: [{ _tag: "completeFile", path: "README.md" }],
         }),
@@ -166,6 +196,7 @@ describe("@repo/domain Plan", () => {
       name: "conflicted outcomes without diagnostics",
       construct: () =>
         new Plan({
+          baseline,
           outcomes: [
             {
               _tag: "complete",
@@ -188,6 +219,7 @@ describe("@repo/domain Plan", () => {
   it("should reject invalid relationships when decoding", () => {
     expect(() =>
       Schema.decodeSync(Plan)({
+        baseline,
         outcomes: [],
         conflicts: [{ _tag: "completeFile", path: "README.md" }],
       }),
diff --git a/packages/domain/src/Plan.ts b/packages/domain/src/Plan.ts
index d4caa7e..cb7abe1 100644
--- a/packages/domain/src/Plan.ts
+++ b/packages/domain/src/Plan.ts
@@ -33,10 +33,27 @@ export const RepoSnapshot = Schema.Struct({
   paths: Schema.Array(RepoSnapshotPath),
 });
 
+/** The repository state against which a Plan was computed. */
+export const PlanBaselinePath = Schema.TaggedUnion({
+  missing: { path: Schema.String },
+  directory: { path: Schema.String },
+  file: { path: Schema.String, sha256: Schema.String },
+});
+
+export const PlanBaseline = Schema.Struct({
+  root: Schema.String,
+  paths: Schema.Array(PlanBaselinePath),
+});
+
 export class PlanFailure extends Schema.TaggedError<PlanFailure>()(
   "PlanFailure",
   {
-    reason: Schema.Literals(["repoRootNotEmpty", "invalidPlanIntent"]),
+    reason: Schema.Literals([
+      "repoRootNotEmpty",
+      "invalidPlanIntent",
+      "repoStateUnsupported",
+      "repoStateChanged",
+    ]),
     message: Schema.String,
   },
 ) {}
@@ -218,10 +235,12 @@ const duplicates = (values: ReadonlyArray<string>): ReadonlyArray<string> =>
   );
 
 const PlanFields = Schema.Struct({
+  baseline: PlanBaseline,
   outcomes: Schema.Array(PlanOutcome),
   conflicts: Schema.Array(PlanConflict),
 }).check(
-  Schema.makeFilter(({ conflicts, outcomes }) => {
+  Schema.makeFilter(({ baseline, conflicts, outcomes }) => {
+    const baselinePaths = baseline.paths.map((entry) => entry.path);
     const outcomePaths = outcomes.map((outcome) => outcome.path);
     const conflictKeys = conflicts.map(planConflictKey);
     const conflictedOutcomePaths = new Set(
@@ -232,6 +251,9 @@ const PlanFields = Schema.Struct({
     const conflictPaths = new Set(conflicts.map((conflict) => conflict.path));
 
     return [
+      ...duplicates(baselinePaths).map(
+        (path) => `Plan baseline paths must be unique; duplicate path: ${path}`,
+      ),
       ...duplicates(outcomePaths).map(
         (path) => `Plan outcome paths must be unique; duplicate path: ${path}`,
       ),
@@ -260,8 +282,8 @@ const PlanFields = Schema.Struct({
  *
  * A Plan pairs each contributed file path with a classification (create,
  * modify, unchanged, or conflict) and its resolved contents or composition
- * operations. It also surfaces detected conflicts that require user decisions
- * before execution.
+ * operations. It also records the inspected repository state and surfaces
+ * detected conflicts that require user decisions before execution.
  *
  * The Plan is policy-free: it records what *would* happen but does not make
  * apply decisions. Those belong to the Apply stage via ApplyDecision entries.
@@ -272,6 +294,10 @@ const PlanFields = Schema.Struct({
 export class Plan extends Schema.Class<Plan>("Plan")(PlanFields) {
   toSorted(): Plan {
     return new Plan({
+      baseline: {
+        root: this.baseline.root,
+        paths: [...this.baseline.paths].sort(pathOrd),
+      },
       outcomes: [...this.outcomes].sort(pathOrd),
       conflicts: [...this.conflicts].sort(
         Order.mapInput(Order.String, planConflictKey),
diff --git a/packages/scaffold/src/service/ScaffoldFormatter.test.ts b/packages/scaffold/src/service/ScaffoldFormatter.test.ts
index 88ef8be..32aa230 100644
--- a/packages/scaffold/src/service/ScaffoldFormatter.test.ts
+++ b/packages/scaffold/src/service/ScaffoldFormatter.test.ts
@@ -126,6 +126,7 @@ describe("ScaffoldFormatter", () => {
       Effect.gen(function* () {
         const formatter = yield* ScaffoldFormatter;
         const plan = new Plan({
+          baseline: { root: "/repo", paths: [] },
           outcomes: [],
           conflicts: [],
         });
@@ -146,6 +147,16 @@ describe("ScaffoldFormatter", () => {
         Effect.gen(function* () {
           const formatter = yield* ScaffoldFormatter;
           const plan = new Plan({
+            baseline: {
+              root: "/repo",
+              paths: [
+                "packages/domain/src/Api.ts",
+                "packages/domain/src/index.ts",
+                "packages/domain/tsconfig.json",
+                "README.md",
+                "package.json",
+              ].map((path) => ({ _tag: "missing" as const, path })),
+            },
             outcomes: [
               {
                 _tag: "complete",
@@ -246,6 +257,10 @@ describe("ScaffoldFormatter", () => {
       Effect.gen(function* () {
         const formatter = yield* ScaffoldFormatter;
         const plan = new Plan({
+          baseline: {
+            root: "/repo",
+            paths: [{ _tag: "missing", path: "apps/web/src/App.tsx" }],
+          },
           outcomes: [
             {
               _tag: "composed",
diff --git a/packages/scaffold/src/service/apply/ApplyPreviewService.test.ts b/packages/scaffold/src/service/apply/ApplyPreviewService.test.ts
index 7cfcdf8..cd8215a 100644
--- a/packages/scaffold/src/service/apply/ApplyPreviewService.test.ts
+++ b/packages/scaffold/src/service/apply/ApplyPreviewService.test.ts
@@ -1,6 +1,7 @@
 // This test intentionally constructs a Windows Path service from Node's win32 implementation.
 // @effect-diagnostics nodeBuiltinImport:off
 
+import { createHash } from "node:crypto";
 import nodePath from "node:path";
 import { MemoryFileSystem } from "@effect-vfs/memory";
 import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
@@ -12,6 +13,7 @@ import {
   type PlanOutcome,
 } from "@repo/domain/Plan";
 import { Effect, FileSystem, Layer, Path, Schema } from "effect";
+import { RepositoryStateService } from "../plan/RepositoryStateService";
 import { ApplyPreviewService } from "./ApplyPreviewService";
 
 const repoRoot = "/repo";
@@ -44,9 +46,24 @@ const composed = (
 const makeApply = (
   outcomes: ReadonlyArray<typeof PlanOutcome.Type>,
   decisions: ReadonlyArray<typeof ApplyDecision.Type> = [],
+  root = repoRoot,
+  existingContents: Readonly<Record<string, string>> = {},
 ) =>
   new Apply({
     plan: new Plan({
+      baseline: {
+        root,
+        paths: outcomes.map((outcome) => {
+          const contents = existingContents[outcome.path];
+          return contents === undefined
+            ? { _tag: "missing" as const, path: outcome.path }
+            : {
+                _tag: "file" as const,
+                path: outcome.path,
+                sha256: createHash("sha256").update(contents).digest("hex"),
+              };
+        }),
+      },
       outcomes: [...outcomes],
       conflicts: outcomes
         .filter((outcome) => outcome.classification === "conflict")
@@ -107,6 +124,79 @@ describe("ApplyPreviewService", () => {
     }).pipe(Effect.provide(TestLayer)),
   );
 
+  it.effect("should preserve BOM-prefixed baseline bytes in file preview", () =>
+    Effect.gen(function* () {
+      const hostFileSystem = yield* FileSystem.FileSystem;
+      const service = yield* ApplyPreviewService;
+      const original = "\uFEFFuser code";
+      yield* hostFileSystem.makeDirectory(repoRoot, { recursive: true });
+      yield* hostFileSystem.writeFileString(
+        `${repoRoot}/existing.ts`,
+        original,
+      );
+
+      const result = yield* service.preview({
+        apply: makeApply(
+          [
+            complete("existing.ts", "unchanged", "user code"),
+            complete("created.ts", "create", "generated code"),
+          ],
+          [],
+          repoRoot,
+          { "existing.ts": original },
+        ),
+        repoRoot,
+      });
+
+      expect(result.apply.created).toEqual(["created.ts"]);
+      expect(result.files).toEqual([
+        { path: "created.ts", status: "created", contents: "generated code" },
+      ]);
+      expect(yield* hostFileSystem.readFile(`${repoRoot}/existing.ts`)).toEqual(
+        new TextEncoder().encode(original),
+      );
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    "should preserve unchanged baseline files while previewing writes",
+    () =>
+      Effect.gen(function* () {
+        const hostFileSystem = yield* FileSystem.FileSystem;
+        const service = yield* ApplyPreviewService;
+        yield* hostFileSystem.makeDirectory(repoRoot, { recursive: true });
+        yield* hostFileSystem.writeFileString(
+          `${repoRoot}/existing.ts`,
+          "user code",
+        );
+
+        const result = yield* service.preview({
+          apply: makeApply(
+            [
+              complete("existing.ts", "unchanged", "user code"),
+              complete("created.ts", "create", "generated code"),
+            ],
+            [],
+            repoRoot,
+            { "existing.ts": "user code" },
+          ),
+          repoRoot,
+        });
+
+        expect(result.apply.created).toEqual(["created.ts"]);
+        expect(result.apply.skipped).toEqual(["existing.ts"]);
+        expect(result.files).toEqual([
+          { path: "created.ts", status: "created", contents: "generated code" },
+        ]);
+        expect(
+          yield* hostFileSystem.readFileString(`${repoRoot}/existing.ts`),
+        ).toBe("user code");
+        expect(yield* hostFileSystem.exists(`${repoRoot}/created.ts`)).toBe(
+          false,
+        );
+      }).pipe(Effect.provide(TestLayer)),
+  );
+
   it.effect("should preserve the host file when composing", () =>
     Effect.gen(function* () {
       const hostFileSystem = yield* FileSystem.FileSystem;
@@ -119,15 +209,20 @@ describe("ApplyPreviewService", () => {
       );
 
       const result = yield* service.preview({
-        apply: makeApply([
-          composed("package.json", "modify", [
-            {
-              _tag: "json-pkg-scripts",
-              fileType: "json",
-              entries: [{ name: "dev", value: "vite" }],
-            },
-          ]),
-        ]),
+        apply: makeApply(
+          [
+            composed("package.json", "modify", [
+              {
+                _tag: "json-pkg-scripts",
+                fileType: "json",
+                entries: [{ name: "dev", value: "vite" }],
+              },
+            ]),
+          ],
+          [],
+          repoRoot,
+          { "package.json": original },
+        ),
         repoRoot,
       });
 
@@ -182,19 +277,35 @@ describe("ApplyPreviewService", () => {
       );
       const original = encodeJson({ name: "windows-app" });
       yield* hostFileSystem.writeFileString(packageJsonPath, original);
+      const windowsBaseline = yield* Effect.gen(function* () {
+        const state = yield* RepositoryStateService;
+        return yield* state.capture({
+          repoRoot: windowsRepoRoot,
+          paths: ["package.json"],
+        });
+      }).pipe(
+        Effect.provide(
+          RepositoryStateService.layer.pipe(Layer.provide(hostLayer)),
+        ),
+      );
 
       const result = yield* Effect.gen(function* () {
         const service = yield* ApplyPreviewService;
         return yield* service.preview({
-          apply: makeApply([
-            composed("package.json", "modify", [
-              {
-                _tag: "json-pkg-scripts",
-                fileType: "json",
-                entries: [{ name: "dev", value: "vite" }],
-              },
-            ]),
-          ]),
+          apply: makeApply(
+            [
+              composed("package.json", "modify", [
+                {
+                  _tag: "json-pkg-scripts",
+                  fileType: "json",
+                  entries: [{ name: "dev", value: "vite" }],
+                },
+              ]),
+            ],
+            [],
+            windowsBaseline.root,
+            { "package.json": original },
+          ),
           repoRoot: windowsRepoRoot,
         });
       }).pipe(Effect.provide(previewLayer));
diff --git a/packages/scaffold/src/service/apply/ApplyPreviewService.ts b/packages/scaffold/src/service/apply/ApplyPreviewService.ts
index e78a39b..81defe6 100644
--- a/packages/scaffold/src/service/apply/ApplyPreviewService.ts
+++ b/packages/scaffold/src/service/apply/ApplyPreviewService.ts
@@ -1,12 +1,19 @@
 import { MemoryFileSystem } from "@effect-vfs/memory";
 import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
-import { type Apply, ApplyFailure, type ApplyResult } from "@repo/domain/Apply";
+import {
+  Apply,
+  ApplyFailure,
+  ApplyResult,
+  StalePlanFailure,
+} from "@repo/domain/Apply";
 import { pathOrd } from "@repo/domain/Order";
+import { Plan } from "@repo/domain/Plan";
 import { Array as Arr, Context, Effect, FileSystem, Layer, Path } from "effect";
 import {
   type ApplyPreviewFile,
   ApplyPreviewFileSchema,
 } from "../../RecipePreviewSchema";
+import { RepositoryStateService } from "../plan/RepositoryStateService";
 import { ApplyService } from "./ApplyService";
 
 export type { ApplyPreviewFile };
@@ -21,7 +28,7 @@ export interface ApplyPreviewServiceShape {
   readonly preview: (input: {
     readonly apply: Apply;
     readonly repoRoot: string;
-  }) => Effect.Effect<ApplyPreview, ApplyFailure, never>;
+  }) => Effect.Effect<ApplyPreview, ApplyFailure | StalePlanFailure, never>;
 }
 
 export class ApplyPreviewService extends Context.Service<
@@ -32,6 +39,7 @@ export class ApplyPreviewService extends Context.Service<
     const hostFileSystem = yield* FileSystem.FileSystem;
     const hostPath = yield* Path.Path;
     const virtualPath = yield* Path.Path.pipe(Effect.provide(Path.layer));
+    const repositoryState = yield* RepositoryStateService;
 
     const preview = Effect.fn("ApplyPreviewService.preview")(function* ({
       apply,
@@ -40,28 +48,44 @@ export class ApplyPreviewService extends Context.Service<
       readonly apply: Apply;
       readonly repoRoot: string;
     }) {
+      const initialChanges = yield* repositoryState.verify({
+        baseline: apply.plan.baseline,
+        repoRoot,
+      });
+      if (initialChanges.length > 0) {
+        return yield* new StalePlanFailure({
+          changes: initialChanges,
+          partialResult: new ApplyResult({
+            created: [],
+            modified: [],
+            skipped: [],
+            failed: [],
+          }),
+          message: `Repository changed since planning: ${initialChanges.map((change) => `${change.path} (${change.kind})`).join(", ")}. Replan and try again.`,
+        });
+      }
       const memoryFileSystem = yield* MemoryFileSystem.make.pipe(
         Effect.provide(BrowserCrypto.layer),
       );
       const workspaceRoot = "/workspace";
-      const decisions = new Map(
-        Arr.map(apply.decisions, (decision) => [decision.path, decision.value]),
-      );
-      const relevantPaths = Arr.map(
-        Arr.filter(
-          apply.plan.outcomes,
-          (outcome) =>
-            outcome.classification !== "unchanged" &&
-            !(
-              outcome.classification === "conflict" &&
-              decisions.get(outcome.path) === "skip"
-            ),
-        ),
-        (outcome) => outcome.path,
+      yield* memoryFileSystem
+        .makeDirectory(workspaceRoot, { recursive: true })
+        .pipe(
+          Effect.mapError(
+            (error) =>
+              new ApplyFailure({
+                reason: "executionFailure",
+                message: `Could not initialize apply preview: ${error.message}`,
+              }),
+          ),
+        );
+      const baselinePaths = Arr.map(
+        apply.plan.baseline.paths,
+        (entry) => entry.path,
       );
 
       yield* Effect.forEach(
-        relevantPaths,
+        baselinePaths,
         (relativePath) =>
           Effect.gen(function* () {
             const sourcePath = hostPath.join(repoRoot, relativePath);
@@ -99,24 +123,22 @@ export class ApplyPreviewService extends Context.Service<
               return;
             }
 
-            const contents = yield* hostFileSystem
-              .readFileString(sourcePath)
-              .pipe(
-                Effect.mapError(
-                  (error) =>
-                    new ApplyFailure({
-                      reason: "repoRootInvalid",
-                      message: `Could not read ${sourcePath} during apply preview: ${error.message}`,
-                    }),
-                ),
-              );
+            const contents = yield* hostFileSystem.readFile(sourcePath).pipe(
+              Effect.mapError(
+                (error) =>
+                  new ApplyFailure({
+                    reason: "repoRootInvalid",
+                    message: `Could not read ${sourcePath} during apply preview: ${error.message}`,
+                  }),
+              ),
+            );
             yield* memoryFileSystem
               .makeDirectory(virtualPath.dirname(memoryPath), {
                 recursive: true,
               })
               .pipe(
                 Effect.andThen(
-                  memoryFileSystem.writeFileString(memoryPath, contents),
+                  memoryFileSystem.writeFile(memoryPath, contents),
                 ),
                 Effect.mapError(
                   (error) =>
@@ -130,6 +152,23 @@ export class ApplyPreviewService extends Context.Service<
         { concurrency: 1, discard: true },
       );
 
+      const finalChanges = yield* repositoryState.verify({
+        baseline: apply.plan.baseline,
+        repoRoot,
+      });
+      if (finalChanges.length > 0) {
+        return yield* new StalePlanFailure({
+          changes: finalChanges,
+          partialResult: new ApplyResult({
+            created: [],
+            modified: [],
+            skipped: [],
+            failed: [],
+          }),
+          message: `Repository changed since planning: ${finalChanges.map((change) => `${change.path} (${change.kind})`).join(", ")}. Replan and try again.`,
+        });
+      }
+
       const memoryLayer = Layer.mergeAll(
         Layer.succeed(FileSystem.FileSystem, memoryFileSystem),
         Layer.succeed(Path.Path, virtualPath),
@@ -137,9 +176,27 @@ export class ApplyPreviewService extends Context.Service<
       const applyLayer = Layer.fresh(ApplyService.layer).pipe(
         Layer.provide(memoryLayer),
       );
+      const previewApply = new Apply({
+        plan: new Plan({
+          baseline: {
+            root: workspaceRoot,
+            paths: Arr.map(apply.plan.baseline.paths, (entry) =>
+              entry.path === "." && entry._tag === "missing"
+                ? { _tag: "directory" as const, path: entry.path }
+                : entry,
+            ),
+          },
+          outcomes: [...apply.plan.outcomes],
+          conflicts: [...apply.plan.conflicts],
+        }),
+        decisions: [...apply.decisions],
+      });
       const result = yield* Effect.gen(function* () {
         const applyService = yield* ApplyService;
-        return yield* applyService.apply({ apply, repoRoot: workspaceRoot });
+        return yield* applyService.apply({
+          apply: previewApply,
+          repoRoot: workspaceRoot,
+        });
       }).pipe(Effect.provide(applyLayer));
 
       const successfulPaths = Arr.sort(
@@ -185,5 +242,5 @@ export class ApplyPreviewService extends Context.Service<
 }) {
   static readonly layer = Layer.effect(ApplyPreviewService)(
     ApplyPreviewService.make,
-  );
+  ).pipe(Layer.provide(RepositoryStateService.layer));
 }
diff --git a/packages/scaffold/src/service/apply/ApplyService.test.ts b/packages/scaffold/src/service/apply/ApplyService.test.ts
index 41283bb..34b7b24 100644
--- a/packages/scaffold/src/service/apply/ApplyService.test.ts
+++ b/packages/scaffold/src/service/apply/ApplyService.test.ts
@@ -23,6 +23,7 @@ import {
   PlatformError,
   Schema,
 } from "effect";
+import { RepositoryStateService } from "../plan/RepositoryStateService";
 import { ApplyService } from "./ApplyService";
 import {
   CompositionEngine,
@@ -130,6 +131,10 @@ const makeFileSystemLayer = (entries: Record<string, MockPathEntry>) => {
   });
 };
 
+const mockRepositoryStateLayer = Layer.succeed(RepositoryStateService, {
+  verify: () => Effect.succeed([]),
+} as never);
+
 const makeApplyServiceLayer = ({
   write,
   compose,
@@ -164,6 +169,7 @@ const makeApplyServiceLayer = ({
         } satisfies CompositionEngineShape),
         makeFileSystemLayer(entries),
         Path.layer,
+        mockRepositoryStateLayer,
       ),
     ),
   );
@@ -177,6 +183,13 @@ const makeApply = ({
 }) =>
   new ApplyIntent({
     plan: new Plan({
+      baseline: {
+        root: testRepoRoot,
+        paths: outcomes.map((outcome) => ({
+          _tag: "missing" as const,
+          path: outcome.path,
+        })),
+      },
       outcomes: [...outcomes],
       conflicts: outcomes
         .filter((outcome) => outcome.classification === "conflict")
@@ -810,6 +823,7 @@ describe("ApplyService", () => {
                 },
               }),
               Path.layer,
+              mockRepositoryStateLayer,
             ),
           ),
         );
@@ -877,6 +891,7 @@ describe("ApplyService", () => {
                   },
                 }),
                 Path.layer,
+                mockRepositoryStateLayer,
               ),
             ),
           );
diff --git a/packages/scaffold/src/service/apply/ApplyService.ts b/packages/scaffold/src/service/apply/ApplyService.ts
index c0db535..e1efe53 100644
--- a/packages/scaffold/src/service/apply/ApplyService.ts
+++ b/packages/scaffold/src/service/apply/ApplyService.ts
@@ -3,6 +3,7 @@ import {
   type ApplyFailedPath,
   ApplyFailure,
   ApplyResult,
+  StalePlanFailure,
 } from "@repo/domain/Apply";
 import { CompositionOperation } from "@repo/domain/Plan";
 import {
@@ -16,6 +17,7 @@ import {
   Path,
   Schema,
 } from "effect";
+import { RepositoryStateService } from "../plan/RepositoryStateService";
 import { CompositionEngine } from "./CompositionEngine";
 import { type ApplyWriteRequest, WriteEngine } from "./WriteEngine";
 
@@ -75,11 +77,11 @@ export interface ApplyServiceShape {
   readonly apply: (input: {
     readonly apply: typeof Apply.Type;
     readonly repoRoot: string;
-  }) => Effect.Effect<ApplyResult, ApplyFailure, never>;
+  }) => Effect.Effect<ApplyResult, ApplyFailure | StalePlanFailure, never>;
   readonly preview: (input: {
     readonly apply: typeof Apply.Type;
     readonly repoRoot: string;
-  }) => Effect.Effect<ApplyResult, ApplyFailure, never>;
+  }) => Effect.Effect<ApplyResult, ApplyFailure | StalePlanFailure, never>;
 }
 
 export class ApplyService extends Context.Service<
@@ -91,9 +93,23 @@ export class ApplyService extends Context.Service<
     const compositionEngine = yield* CompositionEngine;
     const fileSystem = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
+    const repositoryState = yield* RepositoryStateService;
 
     const validateApplyIntent = Effect.fn("ApplyService.validateApplyIntent")(
       function* (apply: typeof Apply.Type) {
+        const baselinePaths = new Set(
+          apply.plan.baseline.paths.map((entry) => entry.path),
+        );
+        const uncoveredOutcome = Arr.findFirst(
+          apply.plan.outcomes,
+          (outcome) => !baselinePaths.has(outcome.path),
+        );
+        if (Option.isSome(uncoveredOutcome)) {
+          return yield* new ApplyFailure({
+            reason: "invalidApplyIntent",
+            message: `Plan baseline does not cover ${uncoveredOutcome.value.path}.`,
+          });
+        }
         const conflictPaths = new Set(
           Arr.map(
             Arr.filter(
@@ -378,28 +394,117 @@ export class ApplyService extends Context.Service<
     const executeWrites = Effect.fn("ApplyService.executeWrites")(function* ({
       repoRoot,
       writeRequests,
+      applyIntent,
+      skippedPaths,
     }: {
       repoRoot: string;
       writeRequests: ReadonlyArray<ApplyWriteRequest>;
+      applyIntent: typeof Apply.Type;
+      skippedPaths: ReadonlySet<string>;
     }) {
-      return yield* Effect.all(
-        Arr.map(writeRequests, (writeRequest) =>
-          writeEngine.write({ repoRoot, write: writeRequest }).pipe(
-            Effect.catch((error) =>
-              Effect.succeed({
-                path: writeRequest.path,
-                status: "failure" as const,
-                reason: error.message,
-              }),
-            ),
-          ),
-        ),
-        {
-          concurrency: 1,
-        },
+      const attempts: Array<WriteAttempt> = [];
+      const createdDirectories = new Set<string>();
+      yield* Effect.forEach(
+        writeRequests,
+        (writeRequest) =>
+          Effect.gen(function* () {
+            const relevantPaths = applyIntent.plan.baseline.paths
+              .filter(
+                (entry) =>
+                  entry.path === "." ||
+                  entry.path === writeRequest.path ||
+                  writeRequest.path.startsWith(`${entry.path}/`),
+              )
+              .map((entry) => entry.path);
+            const changes = yield* repositoryState.verify({
+              baseline: {
+                root: applyIntent.plan.baseline.root,
+                paths: applyIntent.plan.baseline.paths.map((entry) =>
+                  createdDirectories.has(entry.path)
+                    ? { _tag: "directory" as const, path: entry.path }
+                    : entry,
+                ),
+              },
+              repoRoot,
+              paths: relevantPaths,
+            });
+            if (changes.length > 0) {
+              return yield* new StalePlanFailure({
+                changes,
+                partialResult: toApplyResult({
+                  skippedPaths,
+                  writeAttempts: attempts,
+                }),
+                message: stalePlanMessage(
+                  changes,
+                  toApplyResult({ skippedPaths, writeAttempts: attempts }),
+                ),
+              });
+            }
+            const attempt = yield* writeEngine
+              .write({ repoRoot, write: writeRequest })
+              .pipe(
+                Effect.catch((error) =>
+                  Effect.succeed({
+                    path: writeRequest.path,
+                    status: "failure" as const,
+                    reason: error.message,
+                  }),
+                ),
+              );
+            attempts.push(attempt);
+            if (attempt.status === "created" || attempt.status === "modified") {
+              applyIntent.plan.baseline.paths
+                .filter(
+                  (entry) =>
+                    entry._tag === "missing" &&
+                    (entry.path === "." ||
+                      writeRequest.path.startsWith(`${entry.path}/`)),
+                )
+                .forEach((entry) => createdDirectories.add(entry.path));
+            }
+          }),
+        { concurrency: 1, discard: true },
       );
+      return attempts;
     });
 
+    const stalePlanMessage = (
+      changes: ReadonlyArray<{ readonly path: string; readonly kind: string }>,
+      partialResult: ApplyResult,
+    ) => {
+      const written = [...partialResult.created, ...partialResult.modified];
+      return `Repository changed since planning: ${changes.map((change) => `${change.path} (${change.kind})`).join(", ")}. ${written.length > 0 ? `Already written: ${written.join(", ")}. ` : ""}Replan and try again.`;
+    };
+
+    const validateBaseline = Effect.fn("ApplyService.validateBaseline")(
+      function* ({
+        applyIntent,
+        repoRoot,
+      }: {
+        applyIntent: typeof Apply.Type;
+        repoRoot: string;
+      }) {
+        const changes = yield* repositoryState.verify({
+          baseline: applyIntent.plan.baseline,
+          repoRoot,
+        });
+        if (changes.length > 0) {
+          const partialResult = new ApplyResult({
+            created: [],
+            modified: [],
+            skipped: [],
+            failed: [],
+          });
+          return yield* new StalePlanFailure({
+            changes,
+            partialResult,
+            message: stalePlanMessage(changes, partialResult),
+          });
+        }
+      },
+    );
+
     const toApplyResult = ({
       skippedPaths,
       writeAttempts,
@@ -460,12 +565,16 @@ export class ApplyService extends Context.Service<
       repoRoot: string;
     }) {
       const actions = yield* materializeFrom(applyIntent);
+      yield* validateBaseline({ applyIntent, repoRoot });
 
       const actionProjection = yield* prepareWrites({ actions, repoRoot });
+      yield* validateBaseline({ applyIntent, repoRoot });
 
       const writeAttempts = yield* executeWrites({
         repoRoot,
         writeRequests: actionProjection.writeRequests,
+        applyIntent,
+        skippedPaths: actionProjection.skippedPaths,
       });
 
       return toApplyResult({
@@ -482,7 +591,9 @@ export class ApplyService extends Context.Service<
       repoRoot: string;
     }) {
       const actions = yield* materializeFrom(applyIntent);
+      yield* validateBaseline({ applyIntent, repoRoot });
       const actionProjection = yield* prepareWrites({ actions, repoRoot });
+      yield* validateBaseline({ applyIntent, repoRoot });
 
       return toApplyResult({
         skippedPaths: actionProjection.skippedPaths,
@@ -493,11 +604,15 @@ export class ApplyService extends Context.Service<
       });
     });
 
-    return { apply, preview } satisfies ApplyServiceShape;
+    return {
+      apply,
+      preview,
+    } satisfies ApplyServiceShape;
   }),
 }) {
   static readonly layer = Layer.effect(ApplyService)(ApplyService.make).pipe(
     Layer.provide(WriteEngine.layer),
     Layer.provide(CompositionEngine.layer),
+    Layer.provide(RepositoryStateService.layer),
   );
 }
diff --git a/packages/scaffold/src/service/plan/PlanService.test.ts b/packages/scaffold/src/service/plan/PlanService.test.ts
index 71b9454..f5e9832 100644
--- a/packages/scaffold/src/service/plan/PlanService.test.ts
+++ b/packages/scaffold/src/service/plan/PlanService.test.ts
@@ -14,6 +14,7 @@ import { ContributionResolver } from "./ContributionResolver";
 import { PlanAssessor } from "./PlanAssessor";
 import { PlanningIntentCompiler } from "./PlanningIntentCompiler";
 import { PlanService } from "./PlanService";
+import { RepositoryStateService } from "./RepositoryStateService";
 import { RepoSnapshotService } from "./RepoSnapshotService";
 
 const testRepoRoot = "/repo";
@@ -36,6 +37,43 @@ const makeRepoSnapshotServiceLayer = (
     load: Effect.fn("MockRepoSnapshotService.load")(load),
   } as never);
 
+const makeRepositoryStateServiceLayer = (
+  load: (args: {
+    readonly paths: ReadonlyArray<string>;
+    readonly repoRoot: string;
+  }) => Effect.Effect<typeof RepoSnapshot.Type, PlanFailure, never>,
+) => {
+  const fromSnapshot = ({
+    repoRoot,
+    repoSnapshot,
+  }: {
+    readonly repoRoot: string;
+    readonly repoSnapshot: typeof RepoSnapshot.Type;
+  }) =>
+    Effect.succeed({
+      root: repoRoot,
+      paths: repoSnapshot.paths.map((entry) =>
+        entry._tag === "file"
+          ? { _tag: "file" as const, path: entry.path, sha256: entry.contents }
+          : entry,
+      ),
+    });
+  return Layer.succeed(RepositoryStateService, {
+    fromSnapshot,
+    capture: ({
+      repoRoot,
+      paths,
+    }: {
+      readonly repoRoot: string;
+      readonly paths: ReadonlyArray<string>;
+    }) =>
+      Effect.flatMap(load({ repoRoot, paths }), (repoSnapshot) =>
+        fromSnapshot({ repoRoot, repoSnapshot }),
+      ),
+    compare: () => [],
+  } as never);
+};
+
 const makeDomainBlueprint = () =>
   new Blueprint({
     nodes: [
@@ -181,6 +219,7 @@ const makePlanServiceLayer = (
     Layer.provide(ContributionResolver.layer),
     Layer.provide(PlanningIntentCompiler.layer),
     Layer.provide(makeRepoSnapshotServiceLayer(load)),
+    Layer.provide(makeRepositoryStateServiceLayer(load)),
     Layer.provide(assessorLayer),
   );
 
diff --git a/packages/scaffold/src/service/plan/PlanService.ts b/packages/scaffold/src/service/plan/PlanService.ts
index 319041e..887d86f 100644
--- a/packages/scaffold/src/service/plan/PlanService.ts
+++ b/packages/scaffold/src/service/plan/PlanService.ts
@@ -19,6 +19,7 @@ import {
   type PlanningIntentPath,
 } from "./PlanAssessor";
 import { PlanningIntentCompiler } from "./PlanningIntentCompiler";
+import { RepositoryStateService } from "./RepositoryStateService";
 import { RepoSnapshotService } from "./RepoSnapshotService";
 
 const formatSchemaIssue = SchemaIssue.makeFormatterDefault();
@@ -43,6 +44,7 @@ export class PlanService extends Context.Service<
     const contribute = yield* ContributionResolver;
     const compiler = yield* PlanningIntentCompiler;
     const snapshot = yield* RepoSnapshotService;
+    const repositoryState = yield* RepositoryStateService;
     const assessor = yield* PlanAssessor;
 
     const build = Effect.fn("PlanService.build")(function* ({
@@ -58,25 +60,47 @@ export class PlanService extends Context.Service<
 
       const repoSnapshot = yield* snapshot.load({
         paths: Arr.fromIterable(
-          new Set(
-            Arr.flatMap(planningPaths, (planningPath) => [
+          new Set([
+            ".",
+            ...Arr.flatMap(planningPaths, (planningPath) => [
               planningPath.path,
               ...collectAncestorPaths(planningPath.path),
             ]),
-          ),
+          ]),
         ),
         repoRoot,
       });
-
-      return yield* projectPlan({ planningPaths, repoSnapshot });
+      const baseline = yield* repositoryState.fromSnapshot({
+        repoRoot,
+        repoSnapshot,
+      });
+      const plan = yield* projectPlan({
+        planningPaths,
+        repoSnapshot,
+        baseline,
+      });
+      const current = yield* repositoryState.capture({
+        repoRoot,
+        paths: baseline.paths.map((entry) => entry.path),
+      });
+      const changes = repositoryState.compare(baseline, current);
+      if (changes.length > 0) {
+        return yield* new PlanFailure({
+          reason: "repoStateChanged",
+          message: `Repository changed during planning: ${changes.map((change) => `${change.path} (${change.kind})`).join(", ")}. Replan and try again.`,
+        });
+      }
+      return plan;
     });
 
     const projectPlan = ({
       planningPaths,
       repoSnapshot,
+      baseline,
     }: {
       planningPaths: ReadonlyArray<PlanningIntentPath>;
       repoSnapshot: typeof RepoSnapshot.Type;
+      baseline: (typeof Plan.Type)["baseline"];
     }) =>
       Effect.gen(function* () {
         const snapshotPaths = new Map(
@@ -122,6 +146,7 @@ export class PlanService extends Context.Service<
         );
 
         const plan = yield* Plan.makeEffect({
+          baseline,
           outcomes: Arr.map(assessedPaths, ({ planningPath, assessment }) =>
             assessor.toPlannedFileOutcome({
               planningPath,
@@ -152,6 +177,7 @@ export class PlanService extends Context.Service<
     Layer.provide(ContributionResolver.layer),
     Layer.provide(PlanningIntentCompiler.layer),
     Layer.provide(RepoSnapshotService.layer),
+    Layer.provide(RepositoryStateService.layer),
     Layer.provide(PlanAssessor.layer),
     Layer.provide(CatalogService.layer),
   );
diff --git a/packages/scaffold/src/service/plan/RepoSnapshotService.test.ts b/packages/scaffold/src/service/plan/RepoSnapshotService.test.ts
index fb7a7de..532703f 100644
--- a/packages/scaffold/src/service/plan/RepoSnapshotService.test.ts
+++ b/packages/scaffold/src/service/plan/RepoSnapshotService.test.ts
@@ -26,6 +26,12 @@ const makeFileSystemLayer = (entries: Record<string, MockPathEntry>) => {
     };
 
   const fileSystem = {
+    realPath: (absolutePath: string) => Effect.succeed(absolutePath),
+    readLink: (absolutePath: string) =>
+      Effect.fail({
+        _tag: "NotSymbolicLink",
+        message: `Not a symbolic link: ${absolutePath}`,
+      }),
     stat: (absolutePath: string) =>
       Match.value(getEntry(absolutePath)).pipe(
         Match.tag("PlatformError", (error) => Effect.fail(error)),
@@ -35,12 +41,12 @@ const makeFileSystemLayer = (entries: Record<string, MockPathEntry>) => {
         ),
         Match.orElse(() => Effect.succeed({ type: "File" as const })),
       ),
-    readFileString: (absolutePath: string) =>
+    readFile: (absolutePath: string) =>
       Match.value(getEntry(absolutePath)).pipe(
         Match.tag("PlatformError", (error) => Effect.fail(error)),
         Match.tag("readError", ({ error }) => Effect.fail(error)),
         Match.when({ _tag: "file" }, ({ contents }) =>
-          Effect.succeed(contents),
+          Effect.succeed(new TextEncoder().encode(contents)),
         ),
         Match.orElse(() =>
           Effect.fail({
@@ -49,7 +55,7 @@ const makeFileSystemLayer = (entries: Record<string, MockPathEntry>) => {
           }),
         ),
       ),
-  } as FileSystem.FileSystem;
+  } as never;
 
   return Layer.mergeAll(
     Layer.succeed(FileSystem.FileSystem, fileSystem),
diff --git a/packages/scaffold/src/service/plan/RepoSnapshotService.ts b/packages/scaffold/src/service/plan/RepoSnapshotService.ts
index ddb3fd3..bcc639e 100644
--- a/packages/scaffold/src/service/plan/RepoSnapshotService.ts
+++ b/packages/scaffold/src/service/plan/RepoSnapshotService.ts
@@ -48,12 +48,35 @@ export class RepoSnapshotService extends Context.Service<RepoSnapshotService>()(
               );
 
               if (pathStat === null) {
+                const link = yield* fileSystem.readLink(absolutePath).pipe(
+                  Effect.map(() => true),
+                  Effect.orElseSucceed(() => false),
+                );
+                if (link) {
+                  return yield* new PlanFailure({
+                    reason: "repoStateUnsupported",
+                    message: `Symbolic link in repository path ${snapshotPath} is unsupported.`,
+                  });
+                }
                 return {
                   _tag: "missing",
                   path: snapshotPath,
                 } satisfies typeof RepoSnapshot.fields.paths.value.Type;
               }
 
+              const isLink =
+                snapshotPath !== "." &&
+                (yield* fileSystem.readLink(absolutePath).pipe(
+                  Effect.map(() => true),
+                  Effect.orElseSucceed(() => false),
+                ));
+              if (isLink) {
+                return yield* new PlanFailure({
+                  reason: "repoStateUnsupported",
+                  message: `Symbolic link in repository path ${snapshotPath} is unsupported.`,
+                });
+              }
+
               if (pathStat.type === "Directory") {
                 return {
                   _tag: "directory",
@@ -61,17 +84,37 @@ export class RepoSnapshotService extends Context.Service<RepoSnapshotService>()(
                 } satisfies typeof RepoSnapshot.fields.paths.value.Type;
               }
 
-              const contents = yield* fileSystem
-                .readFileString(absolutePath)
-                .pipe(
-                  Effect.mapError(
-                    (err) =>
-                      new PlanFailure({
-                        reason: "repoRootNotEmpty",
-                        message: `Could not read ${snapshotPath} during planning: ${err.message}`,
-                      }),
-                  ),
-                );
+              if (pathStat.type !== "File") {
+                return yield* new PlanFailure({
+                  reason: "repoStateUnsupported",
+                  message: `Unsupported repository entry at ${snapshotPath}: ${pathStat.type}.`,
+                });
+              }
+
+              const bytes = yield* fileSystem.readFile(absolutePath).pipe(
+                Effect.mapError(
+                  (err) =>
+                    new PlanFailure({
+                      reason: "repoRootNotEmpty",
+                      message: `Could not read ${snapshotPath} during planning: ${err.message}`,
+                    }),
+                ),
+              );
+
+              const contents = yield* Effect.try({
+                try: () => {
+                  if (bytes.includes(0)) throw new Error("NUL byte");
+                  return new TextDecoder("utf-8", {
+                    fatal: true,
+                    ignoreBOM: true,
+                  }).decode(bytes);
+                },
+                catch: () =>
+                  new PlanFailure({
+                    reason: "repoStateUnsupported",
+                    message: `Non-text repository file at ${snapshotPath} is unsupported.`,
+                  }),
+              });
 
               return {
                 _tag: "file",
diff --git a/packages/scaffold/src/service/plan/RepositoryStateIntegration.test.ts b/packages/scaffold/src/service/plan/RepositoryStateIntegration.test.ts
new file mode 100644
index 0000000..62eeaa7
--- /dev/null
+++ b/packages/scaffold/src/service/plan/RepositoryStateIntegration.test.ts
@@ -0,0 +1,493 @@
+import assert from "node:assert/strict";
+import { MemoryFileSystem } from "@effect-vfs/memory";
+import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
+import { describe, expect, it } from "@effect/vitest";
+import { Apply, StalePlanFailure } from "@repo/domain/Apply";
+import { Blueprint, toAttachedModuleNodeId } from "@repo/domain/Blueprint";
+import { ModuleId, TargetIdentity, TargetKind } from "@repo/domain/Catalog";
+import type { Plan } from "@repo/domain/Plan";
+import { StackConfig } from "@repo/domain/Scaffold";
+import { Effect, FileSystem, Layer, Path } from "effect";
+import { ApplyPreviewService } from "../apply/ApplyPreviewService";
+import { ApplyService } from "../apply/ApplyService";
+import { PlanService } from "./PlanService";
+
+const repoRoot = "/repo";
+const target = new TargetIdentity({
+  kind: TargetKind.make("package"),
+  name: "domain",
+});
+const moduleId = ModuleId.make("domain-api-contracts");
+const moduleNodeId = toAttachedModuleNodeId(target.toKey(), moduleId);
+const blueprint = new Blueprint({
+  nodes: [
+    { _tag: "target", id: target.toKey(), identity: target },
+    {
+      _tag: "attached-module",
+      id: moduleNodeId,
+      targetId: target.toKey(),
+      moduleId,
+    },
+  ],
+  edges: [
+    {
+      id: `owns-module=>${target.toKey()}=>${moduleNodeId}`,
+      from: target.toKey(),
+      to: moduleNodeId,
+      reason: "owns-module",
+    },
+  ],
+}).toSorted();
+const config = new StackConfig({
+  name: "test-project",
+  runtime: { _tag: "bun" },
+});
+
+const TestLayer = Layer.provideMerge(
+  Layer.mergeAll(
+    PlanService.layer,
+    ApplyService.layer,
+    ApplyPreviewService.layer,
+  ),
+  Layer.merge(
+    Layer.provideMerge(MemoryFileSystem.layer, BrowserCrypto.layer),
+    Path.layer,
+  ),
+);
+
+const buildAt = (root: string) =>
+  Effect.gen(function* () {
+    const plans = yield* PlanService;
+    return yield* plans.build({ blueprint, repoRoot: root, config });
+  });
+const build = buildAt(repoRoot);
+
+const intent = (plan: Plan) => new Apply({ plan, decisions: [] });
+
+describe("Plan and Apply repository state", () => {
+  it.effect("plans and applies beneath a missing repository root", () =>
+    Effect.gen(function* () {
+      const files = yield* FileSystem.FileSystem;
+      const root = "/future/repo";
+      const plan = yield* buildAt(root);
+      expect(plan.baseline.root).toBe(root);
+      const previews = yield* ApplyPreviewService;
+      const preview = yield* previews.preview({
+        apply: intent(plan),
+        repoRoot: root,
+      });
+      expect(preview.files.length).toBeGreaterThan(0);
+      expect(yield* files.exists(root)).toBe(false);
+      const service = yield* ApplyService;
+      const result = yield* service.apply({
+        apply: intent(plan),
+        repoRoot: root,
+      });
+      expect(result.created.length).toBeGreaterThan(0);
+      expect(yield* files.exists(root)).toBe(true);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    "accepts an alias that resolves to the planned repository root",
+    () =>
+      Effect.gen(function* () {
+        const files = yield* FileSystem.FileSystem;
+        yield* files.makeDirectory(repoRoot, { recursive: true });
+        yield* files.symlink(repoRoot, "/alias");
+        const plan = yield* build;
+        const service = yield* ApplyService;
+        const result = yield* service.preview({
+          apply: intent(plan),
+          repoRoot: "/alias",
+        });
+        expect(result.failed).toEqual([]);
+      }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("rejects non-text contents at a planned path", () =>
+    Effect.gen(function* () {
+      const files = yield* FileSystem.FileSystem;
+      yield* files.makeDirectory(repoRoot, { recursive: true });
+      const plan = yield* build;
+      const planned = plan.outcomes.find((entry) => entry.path.endsWith(".ts"));
+      assert(planned, "Expected planned TypeScript file");
+      const absolute = `${repoRoot}/${planned.path}`;
+      yield* files.makeDirectory(absolute.slice(0, absolute.lastIndexOf("/")), {
+        recursive: true,
+      });
+      yield* files.writeFile(absolute, Uint8Array.of(0xff, 0x00));
+      const failure = yield* Effect.flip(build);
+      assert(failure._tag === "PlanFailure");
+      expect(failure.reason).toBe("repoStateUnsupported");
+      expect(failure.message).toContain(planned.path);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("rejects a symbolic link at a planned path", () =>
+    Effect.gen(function* () {
+      const files = yield* FileSystem.FileSystem;
+      yield* files.makeDirectory(repoRoot, { recursive: true });
+      const plan = yield* build;
+      const planned = plan.outcomes.find((entry) => entry.path.endsWith(".ts"));
+      assert(planned, "Expected planned TypeScript file");
+      const absolute = `${repoRoot}/${planned.path}`;
+      yield* files.makeDirectory(absolute.slice(0, absolute.lastIndexOf("/")), {
+        recursive: true,
+      });
+      yield* files.writeFileString(
+        "/external.ts",
+        "export const external = true;",
+      );
+      yield* files.symlink("/external.ts", absolute);
+      const failure = yield* Effect.flip(build);
+      assert(failure._tag === "PlanFailure");
+      expect(failure.reason).toBe("repoStateUnsupported");
+      expect(failure.message).toContain(planned.path);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+  it.effect(
+    "rejects a newly created planned path before preview or apply",
+    () =>
+      Effect.gen(function* () {
+        const files = yield* FileSystem.FileSystem;
+        yield* files.makeDirectory(repoRoot, { recursive: true });
+        const plan = yield* build;
+        const planned = plan.baseline.paths.find(
+          (entry) => entry._tag === "missing" && entry.path.endsWith(".ts"),
+        );
+        assert(planned, "Expected a missing planned TypeScript path");
+        const absolute = `${repoRoot}/${planned.path}`;
+        yield* files.makeDirectory(
+          absolute.slice(0, absolute.lastIndexOf("/")),
+          { recursive: true },
+        );
+        yield* files.writeFileString(absolute, "private new content");
+
+        const service = yield* ApplyService;
+        const preview = yield* Effect.flip(
+          service.preview({ apply: intent(plan), repoRoot }),
+        );
+        expect(preview).toBeInstanceOf(StalePlanFailure);
+        assert(preview._tag === "StalePlanFailure");
+        expect(preview.changes).toContainEqual({
+          path: planned.path,
+          kind: "created",
+        });
+        expect(preview.message).not.toContain("private new content");
+
+        const apply = yield* Effect.flip(
+          service.apply({ apply: intent(plan), repoRoot }),
+        );
+        expect(apply).toBeInstanceOf(StalePlanFailure);
+        assert(apply._tag === "StalePlanFailure");
+        expect(apply.partialResult.created).toEqual([]);
+        expect(yield* files.readFileString(absolute)).toBe(
+          "private new content",
+        );
+
+        const previews = yield* ApplyPreviewService;
+        const filesPreview = yield* Effect.flip(
+          previews.preview({ apply: intent(plan), repoRoot }),
+        );
+        expect(filesPreview).toBeInstanceOf(StalePlanFailure);
+      }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    "rejects a different repository even when planned paths match",
+    () =>
+      Effect.gen(function* () {
+        const files = yield* FileSystem.FileSystem;
+        yield* files.makeDirectory(repoRoot, { recursive: true });
+        yield* files.makeDirectory("/other", { recursive: true });
+        const plan = yield* build;
+        const service = yield* ApplyService;
+        const failure = yield* Effect.flip(
+          service.preview({ apply: intent(plan), repoRoot: "/other" }),
+        );
+        expect(failure).toBeInstanceOf(StalePlanFailure);
+        assert(failure._tag === "StalePlanFailure");
+        expect(failure.changes).toContainEqual({
+          path: ".",
+          kind: "rootChanged",
+        });
+      }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("makes a Plan stale after its first successful Apply", () =>
+    Effect.gen(function* () {
+      const files = yield* FileSystem.FileSystem;
+      yield* files.makeDirectory(repoRoot, { recursive: true });
+      const plan = yield* build;
+      const service = yield* ApplyService;
+      const result = yield* service.apply({ apply: intent(plan), repoRoot });
+      expect(result.created.length).toBeGreaterThan(0);
+      const second = yield* Effect.flip(
+        service.apply({ apply: intent(plan), repoRoot }),
+      );
+      expect(second).toBeInstanceOf(StalePlanFailure);
+      assert(second._tag === "StalePlanFailure");
+      expect(second.partialResult.created).toEqual([]);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    "checks an unchanged planned file and accepts restored contents",
+    () =>
+      Effect.gen(function* () {
+        const files = yield* FileSystem.FileSystem;
+        yield* files.makeDirectory(repoRoot, { recursive: true });
+        const service = yield* ApplyService;
+        const firstPlan = yield* build;
+        yield* service.apply({ apply: intent(firstPlan), repoRoot });
+
+        const plan = yield* build;
+        const unchanged = plan.outcomes.find(
+          (entry) => entry.classification === "unchanged",
+        );
+        assert(unchanged, "Expected an unchanged planned path");
+        const absolute = `${repoRoot}/${unchanged.path}`;
+        const original = yield* files.readFileString(absolute);
+        yield* files.writeFileString(absolute, "private changed contents");
+
+        const failure = yield* Effect.flip(
+          service.preview({ apply: intent(plan), repoRoot }),
+        );
+        assert(failure._tag === "StalePlanFailure");
+        expect(failure.changes).toContainEqual({
+          path: unchanged.path,
+          kind: "modified",
+        });
+        expect(failure.message).not.toContain("private changed contents");
+        yield* files.writeFileString(absolute, original);
+
+        const result = yield* service.preview({
+          apply: intent(plan),
+          repoRoot,
+        });
+        expect(result.failed).toEqual([]);
+      }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("rejects deletion of an existing planned file", () =>
+    Effect.gen(function* () {
+      const files = yield* FileSystem.FileSystem;
+      yield* files.makeDirectory(repoRoot, { recursive: true });
+      const service = yield* ApplyService;
+      yield* service.apply({ apply: intent(yield* build), repoRoot });
+
+      const plan = yield* build;
+      const existing = plan.baseline.paths.find(
+        (entry) => entry._tag === "file",
+      );
+      assert(existing, "Expected a file in the Plan baseline");
+      yield* files.remove(`${repoRoot}/${existing.path}`);
+
+      const failure = yield* Effect.flip(
+        service.preview({ apply: intent(plan), repoRoot }),
+      );
+      assert(failure._tag === "StalePlanFailure");
+      expect(failure.changes).toContainEqual({
+        path: existing.path,
+        kind: "deleted",
+      });
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("detects a UTF-8 byte order mark added after planning", () =>
+    Effect.gen(function* () {
+      const files = yield* FileSystem.FileSystem;
+      yield* files.makeDirectory(repoRoot, { recursive: true });
+      const service = yield* ApplyService;
+      yield* service.apply({ apply: intent(yield* build), repoRoot });
+      const plan = yield* build;
+      const existing = plan.baseline.paths.find(
+        (entry) => entry._tag === "file",
+      );
+      assert(existing, "Expected a file in the Plan baseline");
+      const absolute = `${repoRoot}/${existing.path}`;
+      const original = yield* files.readFileString(absolute);
+      yield* files.writeFileString(absolute, `\uFEFF${original}`);
+      const failure = yield* Effect.flip(
+        service.preview({ apply: intent(plan), repoRoot }),
+      );
+      assert(failure._tag === "StalePlanFailure");
+      expect(failure.changes).toContainEqual({
+        path: existing.path,
+        kind: "modified",
+      });
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    "reports all preflight changes, including an ancestor, before writing",
+    () =>
+      Effect.gen(function* () {
+        const files = yield* FileSystem.FileSystem;
+        yield* files.makeDirectory(repoRoot, { recursive: true });
+        const plan = yield* build;
+        const planned = plan.outcomes.find(
+          (entry) =>
+            entry.classification === "create" && entry.path.includes("/"),
+        );
+        assert(planned, "Expected a nested planned file");
+        const ancestor = plan.baseline.paths.find(
+          (entry) =>
+            entry._tag === "missing" &&
+            planned.path.startsWith(`${entry.path}/`),
+        );
+        assert(ancestor, "Expected a missing planned ancestor");
+        const absolute = `${repoRoot}/${planned.path}`;
+        yield* files.makeDirectory(
+          absolute.slice(0, absolute.lastIndexOf("/")),
+          { recursive: true },
+        );
+        yield* files.writeFileString(absolute, "external content");
+
+        const service = yield* ApplyService;
+        const failure = yield* Effect.flip(
+          service.apply({ apply: intent(plan), repoRoot }),
+        );
+        assert(failure._tag === "StalePlanFailure");
+        expect(failure.changes).toContainEqual({
+          path: ancestor.path,
+          kind: "created",
+        });
+        expect(failure.changes).toContainEqual({
+          path: planned.path,
+          kind: "created",
+        });
+        expect(failure.partialResult.created).toEqual([]);
+        expect(failure.partialResult.modified).toEqual([]);
+        expect(yield* files.readFileString(absolute)).toBe("external content");
+        const untouched = plan.outcomes.find(
+          (entry) =>
+            entry.classification === "create" && entry.path !== planned.path,
+        );
+        assert(untouched, "Expected another planned write");
+        expect(yield* files.exists(`${repoRoot}/${untouched.path}`)).toBe(
+          false,
+        );
+      }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("treats a changed skipped conflict as a stale Plan", () =>
+    Effect.gen(function* () {
+      const files = yield* FileSystem.FileSystem;
+      yield* files.makeDirectory(repoRoot, { recursive: true });
+      const firstPlan = yield* build;
+      const service = yield* ApplyService;
+      yield* service.apply({ apply: intent(firstPlan), repoRoot });
+      const candidate = firstPlan.outcomes.find(
+        (entry) =>
+          entry._tag === "composed" && entry.path.endsWith("package.json"),
+      );
+      assert(candidate, "Expected a planned package.json merge");
+      const absolute = `${repoRoot}/${candidate.path}`;
+      yield* files.writeFileString(absolute, "original invalid JSON");
+
+      const plan = yield* build;
+      const conflict = plan.outcomes.find(
+        (entry) =>
+          entry.path === candidate.path && entry.classification === "conflict",
+      );
+      assert(conflict, "Expected a conflict for changed local content");
+      const decisions = plan.outcomes
+        .filter((entry) => entry.classification === "conflict")
+        .map((entry) => ({ path: entry.path, value: "skip" as const }));
+      yield* files.writeFileString(absolute, "changed after planning");
+
+      const failure = yield* Effect.flip(
+        service.apply({ apply: new Apply({ plan, decisions }), repoRoot }),
+      );
+      assert(failure._tag === "StalePlanFailure");
+      expect(failure.changes).toContainEqual({
+        path: candidate.path,
+        kind: "modified",
+      });
+      expect(failure.partialResult.created).toEqual([]);
+      expect(yield* files.readFileString(absolute)).toBe(
+        "changed after planning",
+      );
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    "stops with a partial result when a later path changes during Apply",
+    () =>
+      Effect.gen(function* () {
+        const files = yield* MemoryFileSystem.make.pipe(
+          Effect.provide(BrowserCrypto.layer),
+        );
+        yield* files.makeDirectory(repoRoot, { recursive: true });
+        const trigger = { first: "", later: "" };
+        const wrapped = {
+          ...files,
+          rename: (from: string, to: string) =>
+            files
+              .rename(from, to)
+              .pipe(
+                Effect.tap(() =>
+                  to === trigger.first
+                    ? files
+                        .makeDirectory(
+                          trigger.later.slice(
+                            0,
+                            trigger.later.lastIndexOf("/"),
+                          ),
+                          { recursive: true },
+                        )
+                        .pipe(
+                          Effect.andThen(
+                            files.writeFileString(
+                              trigger.later,
+                              "external late drift",
+                            ),
+                          ),
+                        )
+                    : Effect.void,
+                ),
+              ),
+        };
+        const layer = Layer.provideMerge(
+          Layer.merge(PlanService.layer, ApplyService.layer),
+          Layer.merge(
+            Layer.succeed(FileSystem.FileSystem, wrapped),
+            Path.layer,
+          ),
+        );
+        const result = yield* Effect.gen(function* () {
+          const plan = yield* build;
+          const creates = plan.outcomes.filter(
+            (entry) => entry.classification === "create",
+          );
+          assert(creates.length >= 2, "Expected two planned writes");
+          const first = creates[0];
+          const later = creates[1];
+          assert(first && later);
+          trigger.first = `${repoRoot}/${first.path}`;
+          trigger.later = `${repoRoot}/${later.path}`;
+          const service = yield* ApplyService;
+          return yield* Effect.flip(
+            service.apply({ apply: intent(plan), repoRoot }),
+          );
+        }).pipe(Effect.provide(layer));
+
+        assert(result._tag === "StalePlanFailure");
+        expect(result.changes).toContainEqual({
+          path: trigger.later.slice(`${repoRoot}/`.length),
+          kind: "created",
+        });
+        expect(result.partialResult.created).toContain(
+          trigger.first.slice(`${repoRoot}/`.length),
+        );
+        expect(result.partialResult.created).not.toContain(
+          trigger.later.slice(`${repoRoot}/`.length),
+        );
+        expect(yield* files.readFileString(trigger.later)).toBe(
+          "external late drift",
+        );
+      }),
+  );
+});
diff --git a/packages/scaffold/src/service/plan/RepositoryStateService.ts b/packages/scaffold/src/service/plan/RepositoryStateService.ts
new file mode 100644
index 0000000..af1f8eb
--- /dev/null
+++ b/packages/scaffold/src/service/plan/RepositoryStateService.ts
@@ -0,0 +1,192 @@
+import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
+import {
+  PlanBaseline,
+  type PlanBaselinePath,
+  PlanFailure,
+  type RepoSnapshot,
+} from "@repo/domain/Plan";
+import { Context, Crypto, Effect, FileSystem, Layer, Path } from "effect";
+import { RepoSnapshotService } from "./RepoSnapshotService";
+
+export type RepositoryChange = {
+  readonly path: string;
+  readonly kind:
+    | "created"
+    | "deleted"
+    | "modified"
+    | "typeChanged"
+    | "rootChanged";
+};
+
+export class RepositoryStateService extends Context.Service<RepositoryStateService>()(
+  "RepositoryStateService",
+  {
+    make: Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const crypto = yield* Crypto.Crypto;
+      const snapshot = yield* RepoSnapshotService;
+
+      const canonicalRoot = Effect.fn("RepositoryStateService.canonicalRoot")(
+        function* (repoRoot: string) {
+          const absoluteRoot = path.resolve(repoRoot);
+          let current = absoluteRoot;
+          const suffix: Array<string> = [];
+
+          while (true) {
+            const resolved = yield* fileSystem.realPath(current).pipe(
+              Effect.catchTag("PlatformError", (error) =>
+                error.reason._tag === "NotFound"
+                  ? Effect.succeed(null)
+                  : Effect.fail(error),
+              ),
+              Effect.mapError(
+                () =>
+                  new PlanFailure({
+                    reason: "repoStateUnsupported",
+                    message: "Could not resolve the repository root.",
+                  }),
+              ),
+            );
+            if (resolved !== null) {
+              return path.join(resolved, ...suffix.reverse());
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+              return absoluteRoot;
+            }
+            suffix.push(path.basename(current));
+            current = parent;
+          }
+        },
+      );
+
+      const fromSnapshot = Effect.fn("RepositoryStateService.fromSnapshot")(
+        function* ({
+          repoRoot,
+          repoSnapshot,
+        }: {
+          readonly repoRoot: string;
+          readonly repoSnapshot: typeof RepoSnapshot.Type;
+        }) {
+          const root = yield* canonicalRoot(repoRoot);
+          const paths = yield* Effect.forEach(repoSnapshot.paths, (entry) =>
+            Effect.gen(function* () {
+              if (entry._tag !== "file") {
+                return entry satisfies typeof PlanBaselinePath.Type;
+              }
+              const digest = yield* crypto
+                .digest("SHA-256", new TextEncoder().encode(entry.contents))
+                .pipe(
+                  Effect.mapError(
+                    () =>
+                      new PlanFailure({
+                        reason: "repoStateUnsupported",
+                        message: `Could not fingerprint ${entry.path} during planning.`,
+                      }),
+                  ),
+                );
+              return {
+                _tag: "file" as const,
+                path: entry.path,
+                sha256: Array.from(digest, (byte) =>
+                  byte.toString(16).padStart(2, "0"),
+                ).join(""),
+              };
+            }),
+          );
+          return { root, paths } satisfies typeof PlanBaseline.Type;
+        },
+      );
+
+      const capture = Effect.fn("RepositoryStateService.capture")(function* ({
+        repoRoot,
+        paths,
+      }: {
+        readonly repoRoot: string;
+        readonly paths: ReadonlyArray<string>;
+      }) {
+        const repoSnapshot = yield* snapshot.load({ repoRoot, paths });
+        return yield* fromSnapshot({ repoRoot, repoSnapshot });
+      });
+
+      const compare = (
+        expected: typeof PlanBaseline.Type,
+        actual: typeof PlanBaseline.Type,
+      ): ReadonlyArray<RepositoryChange> => {
+        const actualByPath = new Map(
+          actual.paths.map((entry) => [entry.path, entry] as const),
+        );
+        return [
+          ...(expected.root === actual.root
+            ? []
+            : [{ path: ".", kind: "rootChanged" as const }]),
+          ...expected.paths.flatMap(
+            (entry): ReadonlyArray<RepositoryChange> => {
+              const current = actualByPath.get(entry.path);
+              if (current === undefined)
+                return [{ path: entry.path, kind: "deleted" }];
+              if (entry._tag === current._tag) {
+                return entry._tag === "file" &&
+                  current._tag === "file" &&
+                  entry.sha256 !== current.sha256
+                  ? [{ path: entry.path, kind: "modified" }]
+                  : [];
+              }
+              if (entry._tag === "missing")
+                return [{ path: entry.path, kind: "created" }];
+              if (current._tag === "missing")
+                return [{ path: entry.path, kind: "deleted" }];
+              return [{ path: entry.path, kind: "typeChanged" }];
+            },
+          ),
+        ];
+      };
+
+      const verify = Effect.fn("RepositoryStateService.verify")(function* ({
+        baseline,
+        repoRoot,
+        paths,
+      }: {
+        readonly baseline: typeof PlanBaseline.Type;
+        readonly repoRoot: string;
+        readonly paths?: ReadonlyArray<string>;
+      }) {
+        const currentRoot = yield* canonicalRoot(repoRoot).pipe(
+          Effect.orElseSucceed(() => ""),
+        );
+        const selected =
+          paths === undefined
+            ? baseline.paths
+            : baseline.paths.filter((entry) => paths.includes(entry.path));
+        const changes = yield* Effect.forEach(selected, (entry) =>
+          capture({ repoRoot, paths: [entry.path] }).pipe(
+            Effect.map((actual) =>
+              compare({ root: baseline.root, paths: [entry] }, actual).filter(
+                (change) => change.kind !== "rootChanged",
+              ),
+            ),
+            Effect.orElseSucceed(() => [
+              { path: entry.path, kind: "typeChanged" as const },
+            ]),
+          ),
+        );
+        return [
+          ...(currentRoot === baseline.root
+            ? []
+            : [{ path: ".", kind: "rootChanged" as const }]),
+          ...changes.flat(),
+        ] satisfies ReadonlyArray<RepositoryChange>;
+      });
+
+      return { capture, fromSnapshot, canonicalRoot, compare, verify } as const;
+    }),
+  },
+) {
+  static readonly layer = Layer.effect(RepositoryStateService)(
+    RepositoryStateService.make,
+  ).pipe(
+    Layer.provide(RepoSnapshotService.layer),
+    Layer.provide(BrowserCrypto.layer),
+  );
+}
diff --git a/packages/scaffold/src/service/recipe/RecipePreviewService.ts b/packages/scaffold/src/service/recipe/RecipePreviewService.ts
index 74cfde2..1b1d9af 100644
--- a/packages/scaffold/src/service/recipe/RecipePreviewService.ts
+++ b/packages/scaffold/src/service/recipe/RecipePreviewService.ts
@@ -1,7 +1,7 @@
 import { MemoryFileSystem } from "@effect-vfs/memory";
 import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
 import { CatalogService } from "@repo/catalog";
-import { Apply, ApplyFailure } from "@repo/domain/Apply";
+import { Apply, ApplyFailure, type StalePlanFailure } from "@repo/domain/Apply";
 import type { BlueprintFailure } from "@repo/domain/Blueprint";
 import type { CatalogNotFound } from "@repo/domain/Catalog";
 import type { PlanFailure } from "@repo/domain/Plan";
@@ -29,7 +29,8 @@ export type RecipePreviewError =
   | BlueprintFailure
   | PlanFailure
   | CatalogNotFound
-  | ApplyFailure;
+  | ApplyFailure
+  | StalePlanFailure;
 
 export interface RecipePreviewServiceShape {
   readonly preview: (