@phyzess/pappra 0.1.0-beta.13 → 0.1.0-beta.18

package/dist/app/init.js

@@ -1,23 +1,25 @@
 import { randomUUID } from 'node:crypto';
 import { basename, dirname, join, resolve } from 'node:path';
-import { mkdir, open, readFile, rename, rm, rmdir, writeFile, } from 'node:fs/promises';
+import { mkdir, open, readFile, readdir, rename, rm, rmdir, writeFile, } from 'node:fs/promises';
 import { createDiagnostic, hasErrors, pointer, } from '../schemas/diagnostics.js';
 import { diagnosticCodes } from '../schemas/errors.js';
 import { INIT_CHOICES_SCHEMA, initPlanSchema, parseInitChoices, } from '../schemas/init.js';
 import { machineConfigSchema } from '../schemas/machine.js';
-import { isExternalRepositoryPath, isPathInside, isPortableRelativePath, normalizePortableRelativePath, resolvePortableRelativePath, samePath, } from '../schemas/paths.js';
+import { isExternalRepositoryPath, isPathInside, isPortableRelativePath, normalizePortableRelativePath, resolvePortableRelativePath, samePath, toWorkspaceRelativePath, } from '../schemas/paths.js';
 import { WORKSPACE_SCHEMA, validateWorkspaceConfigSemantics, workspaceConfigSchema, } from '../schemas/workspace.js';
 import { getPackageInfo, getPackageRoot } from '../package-info.js';
 import { spawnSync } from 'node:child_process';
 import { executableOnPath } from '../hosts/detect.js';
 import { HOST_SUPPORT } from '../hosts/integration/support.js';
 import { observePath, resolveRealpath, sha256Digest } from '../infra/fs.js';
+import { inspectGitRepository, } from '../infra/git.js';
 import { inspectMachineConfig, inspectWorkspaceConfig, } from '../workspace/config.js';
 import { discoverWorkspace, } from '../workspace/discover.js';
+import { isExcludedPath } from '../workspace/ignore.js';
 import { resolveWorkspaceRoot } from '../workspace/resolve.js';
 import { buildInitPlan } from '../install/plan.js';
-import { backupPath, ensureStatePathBoundary, readWorkspaceManifest, writeWorkspaceManifest, } from '../install/ownership.js';
-import { beginManagedApply, completeManagedApply, failManagedApply, recordManagedFile, updateMachineRuntime, } from '../install/apply.js';
+import { backupPath, ensureStatePathBoundary, writeBytesAtomic, writeWorkspaceManifest, } from '../install/ownership.js';
+import { beginManagedApply, completeManagedApply, failManagedApply, inspectWorkspaceInstallReadiness, recordManagedFile, updateMachineRuntime, verifyWorkspaceInstallReady, } from '../install/apply.js';
 import { installRuntime, } from '../install/runtime.js';
 const workspaceConfigRelativePath = '.pappra/workspace.json';
 const machineConfigRelativePath = '.pappra/local/machine.json';
@@ -96,6 +98,33 @@ function candidateKey(value) {
 export async function resolveInitRoot(rootPath) {
     const requestedRoot = resolve(rootPath);
     const resolution = await resolveWorkspaceRoot({ startPath: requestedRoot });
+    if (resolution.state === 'incomplete' && resolution.root !== null) {
+        const canonicalRequested = await resolveRealpath(requestedRoot);
+        const marker = join(resolution.root, '.pappra');
+        const local = join(marker, 'local');
+        const markerObservation = await observePath(marker);
+        const localObservation = await observePath(local);
+        const configObservation = await observePath(join(marker, 'workspace.json'));
+        if (canonicalRequested !== null &&
+            samePath(canonicalRequested, resolution.root) &&
+            markerObservation.kind === 'directory' &&
+            configObservation.kind === 'missing' &&
+            ['missing', 'directory'].includes(localObservation.kind) &&
+            (await readdir(marker)).every((name) => name === 'local')) {
+            const ready = await inspectWorkspaceInstallReadiness(resolution.root);
+            if (!ready.ok)
+                return failure('unavailable', ready.code, ready.message, [], ready.nextAction);
+            return {
+                ok: true,
+                value: {
+                    requestedRoot,
+                    root: resolution.root,
+                    registered: false,
+                    diagnostics: resolution.diagnostics.filter((entry) => entry.code !== diagnosticCodes.workspaceRegistrationIncomplete),
+                },
+            };
+        }
+    }
     if (resolution.state === 'unavailable' || resolution.state === 'incomplete') {
         return failureFromDiagnostics('unavailable', resolution.diagnostics, diagnosticCodes.workspaceStartInvalid, `Cannot initialize from ${requestedRoot}.`);
     }
@@ -145,6 +174,9 @@ export async function inspectInitContext(rootPath) {
     if (!rootResult.ok)
         return rootResult;
     const root = rootResult.value.root;
+    const installReady = await inspectWorkspaceInstallReadiness(root);
+    if (!installReady.ok)
+        return failure('unavailable', installReady.code, installReady.message, [], installReady.nextAction);
     const rootIdentity = await observeRootIdentity(root);
     if (rootIdentity === null) {
         return failure('unavailable', diagnosticCodes.workspaceRootInvalid, `Workspace root is no longer a directory: ${root}`, rootResult.value.diagnostics, 'Retry init from an existing workspace root; no plan was produced.');
@@ -252,6 +284,327 @@ const derivedExcludes = [
     'test-results',
 ];
 const derivedValidationScripts = ['lint', 'typecheck', 'test'];
+/**
+ * Pure discovery-based selections shared by derived and interactive setup.
+ * Mode-specific repositories, validation, graph and host choices stay with
+ * their callers.
+ */
+export function deriveCommonInitDefaults(discovery) {
+    const knowledgeCandidates = listKnowledgeCandidates(discovery);
+    const knowledgeSources = [];
+    for (const name of ['AGENTS.md', 'CLAUDE.md']) {
+        const candidate = knowledgeCandidates.find((entry) => entry.path.toLowerCase() === name.toLowerCase());
+        if (candidate !== undefined)
+            knowledgeSources.push(candidate.path);
+    }
+    const docs = knowledgeCandidates.find((entry) => entry.path === 'docs');
+    if (docs !== undefined)
+        knowledgeSources.push(docs.path);
+    return {
+        name: basename(discovery.root),
+        knowledge: {
+            sources: knowledgeSources,
+            newDocuments: '.pappra/knowledge',
+            taskVisibility: 'private',
+        },
+        code: { symbols: 'auto', prepare: 'on-demand' },
+        excludes: [...derivedExcludes],
+    };
+}
+/**
+ * Converts an existing valid workspace/machine pair into a lossless editable
+ * selection draft. Extensions and continuity are intentionally not part of
+ * InitChoices; plan reconstruction preserves them from the existing config.
+ */
+export function existingInitChoices(config, machine) {
+    return {
+        schema: INIT_CHOICES_SCHEMA,
+        name: config.name,
+        workspaceId: config.workspaceId,
+        repositories: config.repositories.map((repository) => ({
+            path: repository.path,
+            id: repository.id,
+            access: repository.access,
+        })),
+        knowledge: {
+            sources: [...config.knowledge.sources],
+            newDocuments: config.knowledge.newDocuments,
+            taskVisibility: config.knowledge.taskVisibility,
+        },
+        code: { ...config.code },
+        validation: config.validation.map((validation) => `workspace-config:${validation.id}`),
+        excludes: [...config.excludes],
+        hosts: [...(machine?.selectedHosts ?? [])],
+    };
+}
+function portableFieldError(label, value) {
+    if (value.includes('\0') || value.includes('\\')) {
+        return `${label} must use forward slashes and must not contain NUL or backslashes.`;
+    }
+    if (value.startsWith('/') ||
+        /^[A-Za-z]:/.test(value) ||
+        value.startsWith('\\\\')) {
+        return `${label} must be relative to the workspace root, not absolute.`;
+    }
+    if (!isPortableRelativePath(value)) {
+        return `${label} must be a workspace-relative path that does not escape the root.`;
+    }
+    return null;
+}
+/**
+ * Immediate UI field feedback using the same name schema, portable-path rules,
+ * literal-prefix exclusion policy and workspace-relative semantics as planning.
+ */
+export function validateInitField(field, value) {
+    if (field === 'name') {
+        const parsed = workspaceConfigSchema.shape.name.safeParse(value.trim());
+        return parsed.success
+            ? null
+            : (parsed.error.issues[0]?.message ?? 'Use a non-empty workspace name.');
+    }
+    if (field === 'newDocuments') {
+        const parsed = workspaceConfigSchema.shape.knowledge.shape.newDocuments.safeParse(value);
+        if (!parsed.success) {
+            return (parsed.error.issues[0]?.message ??
+                'Use a workspace-relative new document destination.');
+        }
+        return portableFieldError('New document destination', value);
+    }
+    if (field === 'repositoryPath') {
+        return portableFieldError('Repository path', value);
+    }
+    if (field === 'knowledgePath') {
+        return portableFieldError('Knowledge source path', value);
+    }
+    for (const entry of value
+        .split(/[,\n]/)
+        .map((item) => item.trim())
+        .filter((item) => item !== '')) {
+        const pathError = portableFieldError('Exclude entry', entry);
+        if (pathError !== null)
+            return pathError;
+        if (/[*?[\]{}]/.test(entry)) {
+            return `Exclude entry "${entry}" contains glob metacharacters; use literal workspace-relative prefixes.`;
+        }
+    }
+    return null;
+}
+async function nestedWorkspaceBoundaryForPath(root, path, kind) {
+    let current = kind === 'directory' ? path : dirname(path);
+    while (!samePath(current, root)) {
+        if (!isPathInside(root, current))
+            return null;
+        const marker = await observePath(join(current, '.pappra'));
+        if (marker.kind !== 'missing')
+            return current;
+        const parent = dirname(current);
+        if (samePath(parent, current) || !isPathInside(root, parent))
+            return null;
+        current = parent;
+    }
+    return null;
+}
+function explicitPathDiagnostic(code, message, location, hint) {
+    return createDiagnostic({
+        code,
+        severity: 'error',
+        message,
+        source: 'init explicit path inspection',
+        pointer: location,
+        hint,
+    });
+}
+/** Inspects one user-entered path only; it never broadens workspace discovery. */
+export async function inspectInitPathAddition(root, kind, inputPath, excludes = [], location = null) {
+    const label = kind === 'repository' ? 'Repository path' : 'Knowledge source path';
+    const pathError = portableFieldError(label, inputPath);
+    if (pathError !== null) {
+        return {
+            ok: false,
+            diagnostics: [
+                explicitPathDiagnostic(diagnosticCodes.initInvalidInput, pathError, location, 'Enter an existing workspace-relative path using forward slashes; absolute and escaping paths are not accepted.'),
+            ],
+        };
+    }
+    if (inputPath === '~' || inputPath.startsWith('~/')) {
+        return {
+            ok: false,
+            diagnostics: [
+                explicitPathDiagnostic(diagnosticCodes.initInvalidInput, `${label} must not use a home-relative path: ${inputPath}`, location, 'Enter a path relative to the resolved workspace root.'),
+            ],
+        };
+    }
+    if (kind === 'repository' && isExternalRepositoryPath(inputPath)) {
+        return {
+            ok: false,
+            diagnostics: [
+                explicitPathDiagnostic(diagnosticCodes.initInvalidInput, 'Explicit repository addition does not create external repository mappings.', location, 'Add an existing checkout located inside the workspace root.'),
+            ],
+        };
+    }
+    const requestedPath = normalizePortableRelativePath(inputPath);
+    const candidatePath = resolvePortableRelativePath(root, requestedPath);
+    if (!isPathInside(root, candidatePath)) {
+        return {
+            ok: false,
+            diagnostics: [
+                explicitPathDiagnostic(diagnosticCodes.initInvalidInput, `${label} escapes the workspace root: ${inputPath}`, location, 'Keep the path within the resolved workspace root.'),
+            ],
+        };
+    }
+    try {
+        const initial = await observePath(candidatePath);
+        if (initial.kind === 'missing') {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(kind === 'repository'
+                        ? diagnosticCodes.repositoryPathMissing
+                        : diagnosticCodes.knowledgeSourceMissing, `${label} does not exist: ${candidatePath}`, location, 'Correct the path or cancel the addition; init does not create the location.'),
+                ],
+            };
+        }
+        const realPath = await resolveRealpath(candidatePath);
+        if (realPath === null) {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(kind === 'repository'
+                        ? diagnosticCodes.repositoryPathMissing
+                        : diagnosticCodes.knowledgeSourceNotReadable, `Cannot resolve ${label.toLowerCase()}: ${candidatePath}`, location, 'Check the entered path and permissions.'),
+                ],
+            };
+        }
+        if (!isPathInside(root, realPath)) {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(kind === 'repository'
+                        ? diagnosticCodes.repositorySymlinkEscape
+                        : diagnosticCodes.knowledgeSourceSymlinkEscape, `${label} resolves outside the workspace root: ${candidatePath} -> ${realPath}`, location, 'Keep the resolved target inside the workspace; explicit additions do not create external mappings.'),
+                ],
+            };
+        }
+        const target = await observePath(realPath);
+        if (target.kind !== 'file' && target.kind !== 'directory') {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(kind === 'repository'
+                        ? diagnosticCodes.repositoryNotGit
+                        : diagnosticCodes.knowledgeSourceNotReadable, `${label} is not an existing regular file or directory: ${realPath}`, location, 'Special files, FIFOs and unreadable locations are not accepted.'),
+                ],
+            };
+        }
+        if (kind === 'repository' && target.kind !== 'directory') {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(diagnosticCodes.repositoryNotGit, `Repository path is not a checkout directory: ${realPath}`, location, 'Enter the exact existing Git checkout root, not a file or a subdirectory.'),
+                ],
+            };
+        }
+        const nested = await nestedWorkspaceBoundaryForPath(root, realPath, target.kind);
+        if (nested !== null) {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(kind === 'repository'
+                        ? diagnosticCodes.repositoryNestedWorkspace
+                        : diagnosticCodes.discoveryNestedWorkspace, `${label} is inside nested workspace ${nested}.`, location, 'Configure the nested workspace separately; outer init does not absorb its paths.'),
+                ],
+            };
+        }
+        const canonicalPath = toWorkspaceRelativePath(root, realPath);
+        if (canonicalPath === null) {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(kind === 'repository'
+                        ? diagnosticCodes.repositorySymlinkEscape
+                        : diagnosticCodes.knowledgeSourceSymlinkEscape, `${label} has no safe workspace-relative identity: ${realPath}`, location, 'Keep the resolved target inside the workspace root.'),
+                ],
+            };
+        }
+        if (isExcludedPath(canonicalPath, excludes)) {
+            const label = kind === 'repository' ? 'Repository' : 'Knowledge source';
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(kind === 'repository'
+                        ? diagnosticCodes.initRepositoryUnknown
+                        : diagnosticCodes.initKnowledgeUnknown, `${label} is excluded by workspace policy: ${canonicalPath}`, location, 'Remove or change the exclude before adding this path.'),
+                ],
+            };
+        }
+        let git = null;
+        if (kind === 'repository') {
+            const inspected = await inspectGitRepository(realPath);
+            if (!inspected.ok) {
+                return {
+                    ok: false,
+                    diagnostics: [
+                        createDiagnostic({
+                            code: inspected.code,
+                            severity: 'error',
+                            message: inspected.message,
+                            source: 'init explicit repository path',
+                            pointer: location,
+                            hint: inspected.nextAction ??
+                                'Check the exact repository path and Git metadata.',
+                        }),
+                    ],
+                };
+            }
+            if (!samePath(inspected.value.root, realPath)) {
+                return {
+                    ok: false,
+                    diagnostics: [
+                        explicitPathDiagnostic(diagnosticCodes.repositoryNotGit, `Entered location is not the exact repository root: ${realPath}; Git resolved ${inspected.value.root}.`, location, 'Enter the checkout root itself; init does not substitute a parent repository.'),
+                    ],
+                };
+            }
+            if (!isPathInside(root, inspected.value.root)) {
+                return {
+                    ok: false,
+                    diagnostics: [
+                        explicitPathDiagnostic(diagnosticCodes.repositorySymlinkEscape, `Repository resolves outside the workspace root: ${inspected.value.root}`, location, 'Use a workspace-local checkout; external mapping creation is not part of init path addition.'),
+                    ],
+                };
+            }
+            git = inspected.value;
+        }
+        if (target.stats === null) {
+            return {
+                ok: false,
+                diagnostics: [
+                    explicitPathDiagnostic(diagnosticCodes.fileUnreadable, `Cannot snapshot ${label.toLowerCase()}: ${realPath}`, location, 'Check the path and permissions, then try the explicit addition again.'),
+                ],
+            };
+        }
+        return {
+            ok: true,
+            observation: {
+                kind,
+                requestedPath,
+                path: canonicalPath,
+                realPath,
+                targetKind: target.kind,
+                device: target.stats.dev,
+                inode: target.stats.ino,
+                git,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            diagnostics: [
+                explicitPathDiagnostic(diagnosticCodes.fileUnreadable, `Cannot inspect ${label.toLowerCase()} ${candidatePath}: ${error instanceof Error ? error.message : String(error)}`, location, 'Check permissions and the path; init does not open document bodies during path addition.'),
+            ],
+        };
+    }
+}
 export function detectedHostVersion(command, pathEnv) {
     const executable = executableOnPath(command, pathEnv);
     if (executable === null)
@@ -290,27 +643,15 @@ export async function deriveInitChoices(discovery, options = {}) {
         });
         return { path, access };
     });
+    const common = deriveCommonInitDefaults(discovery);
     const knowledgeCandidates = listKnowledgeCandidates(discovery);
-    const rootRuleFiles = ['AGENTS.md', 'CLAUDE.md'];
-    const knowledgeSources = [];
-    for (const name of rootRuleFiles) {
-        const candidate = knowledgeCandidates.find((entry) => entry.path.toLowerCase() === name.toLowerCase());
-        if (candidate === undefined)
-            continue;
-        knowledgeSources.push(candidate.path);
+    for (const source of common.knowledge.sources) {
         rules.push({
             field: 'knowledge.sources',
-            value: candidate.path,
-            reason: 'workspace-root rule file reported by discovery',
-        });
-    }
-    const docs = knowledgeCandidates.find((entry) => entry.path === 'docs');
-    if (docs !== undefined) {
-        knowledgeSources.push(docs.path);
-        rules.push({
-            field: 'knowledge.sources',
-            value: docs.path,
-            reason: 'documentation directory reported by discovery',
+            value: source,
+            reason: source === 'docs'
+                ? 'documentation directory reported by discovery'
+                : 'workspace-root rule file reported by discovery',
         });
     }
     const codegraphDetected = executableOnPath('codegraph', pathEnv) !== null &&
@@ -325,12 +666,12 @@ export async function deriveInitChoices(discovery, options = {}) {
     });
     rules.push({
         field: 'code.symbols',
-        value: 'auto',
+        value: common.code.symbols,
         reason: 'symbol providers are detected passively at use time',
     });
     rules.push({
         field: 'code.prepare',
-        value: 'on-demand',
+        value: common.code.prepare,
         reason: 'index preparation stays an explicit, bounded action',
     });
     const validation = [];
@@ -347,7 +688,7 @@ export async function deriveInitChoices(discovery, options = {}) {
     }
     rules.push({
         field: 'excludes',
-        value: derivedExcludes.join(', '),
+        value: common.excludes.join(', '),
         reason: 'built-in defaults keep generated and dependency trees out of scope',
     });
     const hosts = [];
@@ -371,7 +712,7 @@ export async function deriveInitChoices(discovery, options = {}) {
             reason: `host executable reports the pinned version ${version}`,
         });
     }
-    const name = basename(discovery.root);
+    const name = common.name;
     rules.push({
         field: 'name',
         value: name,
@@ -381,14 +722,14 @@ export async function deriveInitChoices(discovery, options = {}) {
         schema: INIT_CHOICES_SCHEMA,
         name,
         repositories,
-        knowledge: {
-            sources: knowledgeSources,
-            newDocuments: '.pappra/knowledge',
-            taskVisibility: 'private',
+        knowledge: common.knowledge,
+        code: {
+            graph,
+            symbols: common.code.symbols,
+            prepare: common.code.prepare,
         },
-        code: { graph, symbols: 'auto', prepare: 'on-demand' },
         validation,
-        excludes: [...derivedExcludes],
+        excludes: [...common.excludes],
         hosts,
     };
     return {
@@ -402,7 +743,7 @@ export async function deriveInitChoices(discovery, options = {}) {
         },
     };
 }
-function selectRepositories(choices, discovery, root) {
+function selectRepositories(choices, discovery, root, additionalRepositories = new Map(), reservedRepositoryIds = []) {
     const diagnostics = [];
     const byKey = new Map();
     for (const repository of discovery.repositories) {
@@ -411,6 +752,14 @@ function selectRepositories(choices, discovery, root) {
             byKey.set(normalizePortableRelativePath(repository.relativePath), repository);
         }
     }
+    for (const [key, repository] of additionalRepositories) {
+        if (!byKey.has(key))
+            byKey.set(key, repository);
+    }
+    const reservedIds = new Set([
+        ...reservedRepositoryIds,
+        ...choices.repositories.flatMap((choice) => choice.id === undefined ? [] : [choice.id]),
+    ]);
     const usedIds = new Set();
     const selected = [];
     const seenRepositories = new Set();
@@ -421,10 +770,10 @@ function selectRepositories(choices, discovery, root) {
             diagnostics.push(createDiagnostic({
                 code: diagnosticCodes.initRepositoryUnknown,
                 severity: 'error',
-                message: `Init selection references an undiscovered repository: ${choice.path}`,
+                message: `Init selection references an undiscovered or uninspected repository: ${choice.path}`,
                 source: 'init choices',
                 pointer: pointer('repositories', index, 'path'),
-                hint: 'Select a repository path reported by discovery; Pappra does not invent repository scopes.',
+                hint: 'Select a discovered checkout or add an existing workspace-relative checkout through the bounded path action.',
             }));
             continue;
         }
@@ -435,7 +784,7 @@ function selectRepositories(choices, discovery, root) {
                 message: `Repository selection repeats ${repository.root}.`,
                 source: 'init choices',
                 pointer: pointer('repositories', index, 'path'),
-                hint: 'Keep one selection per discovered checkout.',
+                hint: 'Keep one selection per canonical checkout.',
             }));
             continue;
         }
@@ -445,9 +794,8 @@ function selectRepositories(choices, discovery, root) {
             (repository.relativePath === null || repository.relativePath === '.'
                 ? basename(root)
                 : basename(repository.relativePath));
-        const id = choice.id
-            ? choice.id
-            : uniqueIdentifier(sanitizeIdentifier(derivedBase), usedIds);
+        const id = choice.id ??
+            uniqueIdentifier(sanitizeIdentifier(derivedBase), new Set([...reservedIds, ...usedIds]));
         if (choice.id !== undefined) {
             if (usedIds.has(choice.id)) {
                 diagnostics.push(createDiagnostic({
@@ -460,8 +808,8 @@ function selectRepositories(choices, discovery, root) {
                 }));
                 continue;
             }
-            usedIds.add(choice.id);
         }
+        usedIds.add(id);
         const configPath = external
             ? repository.configuredPath
             : (repository.relativePath ?? repository.configuredPath ?? '.');
@@ -486,11 +834,16 @@ function selectRepositories(choices, discovery, root) {
     }
     return { selected, diagnostics };
 }
-function selectKnowledgeSources(choices, discovery) {
+function selectKnowledgeSources(choices, discovery, retainedSources = [], explicitSources = new Map()) {
     const allowed = new Map(listKnowledgeCandidates(discovery).map((candidate) => [
         candidateKey(candidate.path),
         candidate.path,
     ]));
+    for (const [key, path] of explicitSources) {
+        if (!allowed.has(key))
+            allowed.set(key, path);
+    }
+    const retained = new Map(retainedSources.map((source) => [candidateKey(source), source]));
     const diagnostics = [];
     const sources = [];
     const seen = new Set();
@@ -498,6 +851,22 @@ function selectKnowledgeSources(choices, discovery) {
         const key = candidateKey(source);
         const canonical = allowed.get(key);
         if (canonical === undefined) {
+            const kept = retained.get(key);
+            if (kept !== undefined) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.initKnowledgeUnknown,
+                    severity: 'warning',
+                    message: `Configured knowledge source is retained but not currently discovered: ${kept}`,
+                    source: 'init choices',
+                    pointer: pointer('knowledge', 'sources', index),
+                    hint: 'Keep the source if it is intentionally unavailable, or remove it explicitly.',
+                }));
+                if (!seen.has(kept)) {
+                    seen.add(kept);
+                    sources.push(kept);
+                }
+                continue;
+            }
             diagnostics.push(createDiagnostic({
                 code: diagnosticCodes.initKnowledgeUnknown,
                 severity: 'error',
@@ -515,13 +884,167 @@ function selectKnowledgeSources(choices, discovery) {
     }
     return { sources, diagnostics };
 }
+function pathObservationKey(kind, path) {
+    return `${kind}:${candidateKey(path)}`;
+}
+function sameInitPathObservation(left, right) {
+    if (left.kind !== right.kind ||
+        candidateKey(left.path) !== candidateKey(right.path) ||
+        !samePath(left.realPath, right.realPath) ||
+        left.targetKind !== right.targetKind ||
+        left.device !== right.device ||
+        left.inode !== right.inode) {
+        return false;
+    }
+    if (left.git === null || right.git === null)
+        return left.git === right.git;
+    return (samePath(left.git.root, right.git.root) &&
+        samePath(left.git.gitDir, right.git.gitDir) &&
+        samePath(left.git.commonDir, right.git.commonDir) &&
+        left.git.kind === right.git.kind);
+}
+function repositorySelectionFromPathObservation(observation) {
+    if (observation.kind !== 'repository' || observation.git === null) {
+        throw new Error('Repository selection requires a Git path observation.');
+    }
+    return {
+        id: null,
+        external: false,
+        access: 'read',
+        root: observation.git.root,
+        relativePath: observation.path,
+        configuredPath: observation.path,
+        git: observation.git,
+        kind: observation.git.kind,
+        diagnostics: [],
+    };
+}
+async function inspectExplicitInitPathSelections(root, choices, discovery, preservedConfig, priorObservations) {
+    const repositories = new Map();
+    const knowledgeSources = new Map();
+    const observations = [];
+    const diagnostics = [];
+    const priorByPath = new Map();
+    for (const observation of priorObservations) {
+        const key = pathObservationKey(observation.kind, observation.path);
+        if (!priorByPath.has(key))
+            priorByPath.set(key, observation);
+    }
+    const discoveredRepositories = new Map();
+    for (const repository of discovery.repositories) {
+        discoveredRepositories.set(repositoryKey(repository), repository);
+        if (repository.relativePath !== null) {
+            discoveredRepositories.set(candidateKey(repository.relativePath), repository);
+        }
+    }
+    const discoveredKnowledge = new Map(listKnowledgeCandidates(discovery).map((candidate) => [
+        candidateKey(candidate.path),
+        candidate.path,
+    ]));
+    const retainedRepositoryPaths = new Set((preservedConfig?.repositories ?? []).map((repository) => candidateKey(repository.path)));
+    const retainedKnowledgePaths = new Set((preservedConfig?.knowledge.sources ?? []).map(candidateKey));
+    const inspectedChoices = new Set();
+    let failureStatus = 'invalid';
+    const inspectChoice = async (kind, inputPath, location) => {
+        const inputKey = candidateKey(inputPath);
+        const inspectionKey = pathObservationKey(kind, inputKey);
+        if (inspectedChoices.has(inspectionKey))
+            return;
+        inspectedChoices.add(inspectionKey);
+        const inspected = await inspectInitPathAddition(root, kind, inputPath, choices.excludes, location);
+        if (!inspected.ok) {
+            diagnostics.push(...inspected.diagnostics);
+            return;
+        }
+        const observation = inspected.observation;
+        const prior = priorByPath.get(pathObservationKey(kind, observation.path)) ??
+            priorByPath.get(inspectionKey);
+        if (prior !== undefined && !sameInitPathObservation(prior, observation)) {
+            failureStatus = 'conflict';
+            diagnostics.push(createDiagnostic({
+                code: diagnosticCodes.initPlanStale,
+                severity: 'error',
+                message: `Explicit ${kind} path changed after it was inspected: ${observation.path}`,
+                source: 'init explicit path inspection',
+                pointer: location,
+                hint: 'Review the changed location and re-enter it deliberately; init does not refresh path identity automatically.',
+            }));
+            return;
+        }
+        observations.push(observation);
+        if (kind === 'repository') {
+            const discovered = [...discovery.repositories].find((entry) => samePath(entry.root, observation.realPath));
+            const source = discovered ?? repositorySelectionFromPathObservation(observation);
+            repositories.set(inputKey, source);
+            repositories.set(candidateKey(observation.path), source);
+        }
+        else {
+            const canonical = discoveredKnowledge.get(candidateKey(observation.path)) ??
+                observation.path;
+            knowledgeSources.set(inputKey, canonical);
+            knowledgeSources.set(candidateKey(observation.path), canonical);
+        }
+    };
+    for (const [index, choice] of choices.repositories.entries()) {
+        const key = candidateKey(choice.path);
+        const hasPriorObservation = priorByPath.has(pathObservationKey('repository', key));
+        if (!hasPriorObservation &&
+            (retainedRepositoryPaths.has(key) ||
+                (discoveredRepositories.has(key) &&
+                    !isExcludedPath(key, choices.excludes)))) {
+            continue;
+        }
+        await inspectChoice('repository', choice.path, pointer('repositories', index, 'path'));
+    }
+    for (const [index, source] of choices.knowledge.sources.entries()) {
+        const key = candidateKey(source);
+        const hasPriorObservation = priorByPath.has(pathObservationKey('knowledge', key));
+        if (!hasPriorObservation &&
+            (retainedKnowledgePaths.has(key) ||
+                (discoveredKnowledge.has(key) &&
+                    !isExcludedPath(key, choices.excludes)))) {
+            continue;
+        }
+        await inspectChoice('knowledge', source, pointer('knowledge', 'sources', index));
+    }
+    if (diagnostics.some((entry) => entry.severity === 'error')) {
+        return { ok: false, status: failureStatus, diagnostics };
+    }
+    return {
+        ok: true,
+        value: { repositories, knowledgeSources, observations },
+    };
+}
+async function revalidateExplicitInitPaths(root, observations, excludes) {
+    const diagnostics = [];
+    for (const previous of observations) {
+        const current = await inspectInitPathAddition(root, previous.kind, previous.path, excludes);
+        if (!current.ok ||
+            !sameInitPathObservation(previous, current.observation)) {
+            diagnostics.push(createDiagnostic({
+                code: diagnosticCodes.initPlanStale,
+                severity: 'error',
+                message: `Explicit ${previous.kind} path changed or became unsafe before the final plan: ${previous.path}`,
+                source: 'init explicit path inspection',
+                pointer: null,
+                hint: 'Review and re-enter the exact path; init does not refresh a stale path observation automatically.',
+            }));
+        }
+    }
+    return diagnostics;
+}
 function findSelectedRepositoryForCandidate(candidate, selected) {
-    for (const repository of selected) {
-        if (candidate.repositoryId !== null &&
-            (candidate.repositoryId === repository.originalId ||
-                candidate.repositoryId === repository.id)) {
-            return repository;
+    if (candidate.repositoryId !== null) {
+        for (const repository of selected) {
+            if (repository.originalId === candidate.repositoryId)
+                return repository;
         }
+        // A configured/discovered repository identity is authoritative. A
+        // different checkout that merely reuses its final selected ID is not a
+        // substitute, and working-directory evidence must not override it.
+        return null;
+    }
+    for (const repository of selected) {
         if (candidate.workingDirectory !== null &&
             samePath(candidate.workingDirectory, repository.repository.root)) {
             return repository;
@@ -529,7 +1052,7 @@ function findSelectedRepositoryForCandidate(candidate, selected) {
     }
     return null;
 }
-function selectValidationEntries(choices, discovery, selected) {
+function selectValidationEntries(choices, discovery, selected, strictExistingBinding = false) {
     const byId = new Map(discovery.validationCandidates.map((candidate) => [
         candidate.id,
         candidate,
@@ -537,6 +1060,12 @@ function selectValidationEntries(choices, discovery, selected) {
     const diagnostics = [];
     const validation = [];
     const usedIds = new Set();
+    const existingIds = new Set();
+    for (const candidate of discovery.validationCandidates) {
+        if (candidate.origin !== 'workspace-config')
+            continue;
+        existingIds.add(candidate.id.slice('workspace-config:'.length));
+    }
     const seen = new Set();
     for (const [index, candidateId] of choices.validation.entries()) {
         if (seen.has(candidateId))
@@ -558,7 +1087,9 @@ function selectValidationEntries(choices, discovery, selected) {
         if (repository === null) {
             diagnostics.push(createDiagnostic({
                 code: diagnosticCodes.initValidationUnbound,
-                severity: 'warning',
+                severity: strictExistingBinding && candidate.origin === 'workspace-config'
+                    ? 'error'
+                    : 'warning',
                 message: `Validation candidate "${candidateId}" is not bound to a selected repository.`,
                 source: 'init choices',
                 pointer: pointer('validation', index),
@@ -566,9 +1097,32 @@ function selectValidationEntries(choices, discovery, selected) {
             }));
             continue;
         }
-        const base = sanitizeIdentifier(candidate.id.replace(/^(?:workspace-config|package-script):/, ''));
+        const existing = candidate.origin === 'workspace-config';
+        const base = existing
+            ? candidate.id.slice('workspace-config:'.length)
+            : sanitizeIdentifier(candidate.id.replace(/^(?:workspace-config|package-script):/, ''));
+        let id;
+        if (existing) {
+            if (usedIds.has(base)) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.initValidationUnknown,
+                    severity: 'error',
+                    message: `Configured validation id "${base}" is selected more than once.`,
+                    source: 'init choices',
+                    pointer: pointer('validation', index),
+                    hint: 'Keep one selection per configured validation id.',
+                }));
+                continue;
+            }
+            id = base;
+            usedIds.add(id);
+        }
+        else {
+            id = uniqueIdentifier(base, new Set([...usedIds, ...existingIds]));
+            usedIds.add(id);
+        }
         validation.push({
-            id: uniqueIdentifier(base, usedIds),
+            id,
             repositoryId: repository.id,
             executable: candidate.executable,
             args: [...candidate.args],
@@ -576,13 +1130,13 @@ function selectValidationEntries(choices, discovery, selected) {
     }
     return { validation, diagnostics };
 }
-function buildWorkspaceConfig(root, choices, discovery, runtimeVersion) {
+function buildWorkspaceConfig(root, choices, discovery, runtimeVersion, options = {}) {
     const diagnostics = [];
-    const repositorySelection = selectRepositories(choices, discovery, root);
+    const repositorySelection = selectRepositories(choices, discovery, root, options.explicitRepositories, options.preserveFrom?.repositories.map((repository) => repository.id) ?? []);
     diagnostics.push(...repositorySelection.diagnostics);
-    const knowledgeSelection = selectKnowledgeSources(choices, discovery);
+    const knowledgeSelection = selectKnowledgeSources(choices, discovery, options.preserveFrom?.knowledge.sources ?? [], options.explicitKnowledgeSources);
     diagnostics.push(...knowledgeSelection.diagnostics);
-    const validationSelection = selectValidationEntries(choices, discovery, repositorySelection.selected);
+    const validationSelection = selectValidationEntries(choices, discovery, repositorySelection.selected, options.strictExistingValidation === true);
     diagnostics.push(...validationSelection.diagnostics);
     if (hasErrors(diagnostics)) {
         return {
@@ -594,7 +1148,7 @@ function buildWorkspaceConfig(root, choices, discovery, runtimeVersion) {
     const name = choices.name?.trim() ?? '';
     const config = {
         schema: WORKSPACE_SCHEMA,
-        workspaceId: choices.workspaceId ?? randomUUID(),
+        workspaceId: options.preserveFrom?.workspaceId ?? choices.workspaceId ?? randomUUID(),
         name: name === '' ? basename(root) || 'workspace' : name,
         runtimeVersion,
         repositories: repositorySelection.selected.map((repository) => ({
@@ -610,7 +1164,10 @@ function buildWorkspaceConfig(root, choices, discovery, runtimeVersion) {
         code: choices.code,
         validation: [...validationSelection.validation],
         excludes: [...new Set(choices.excludes)],
-        extensions: {},
+        extensions: options.preserveFrom?.extensions ?? {},
+        ...(options.preserveFrom?.continuity === undefined
+            ? {}
+            : { continuity: options.preserveFrom.continuity }),
     };
     const parsed = workspaceConfigSchema.safeParse(config);
     if (!parsed.success) {
@@ -649,13 +1206,15 @@ function buildWorkspaceConfig(root, choices, discovery, runtimeVersion) {
         diagnostics,
     };
 }
-function scopeRepositories(config, discovery) {
+function scopeRepositories(config, discovery, selected = []) {
     const byConfiguredPath = new Map(discovery.repositories.map((repository) => [
         repository.configuredPath,
         repository,
     ]));
+    const bySelectedPath = new Map(selected.map((repository) => [candidateKey(repository.path), repository]));
     return config.repositories.map((repository) => {
-        const discovered = byConfiguredPath.get(repository.path);
+        const planned = bySelectedPath.get(candidateKey(repository.path));
+        const discovered = planned?.repository ?? byConfiguredPath.get(repository.path);
         return {
             id: repository.id,
             path: repository.path,
@@ -664,7 +1223,9 @@ function scopeRepositories(config, discovery) {
             root: discovered?.root ?? null,
             kind: discovered?.kind ?? null,
             dirty: discovered?.git.dirty ?? null,
-            declaredBy: 'existing',
+            declaredBy: planned?.originalId === null
+                ? 'planned'
+                : 'existing',
         };
     });
 }
@@ -802,6 +1363,13 @@ export async function planWorkspaceInit(options) {
         choices = parsedChoices.value;
     }
     const existingConfig = context.workspaceInspection.value;
+    if (existingConfig !== null &&
+        options.reconfigure === true &&
+        choices !== null &&
+        choices.workspaceId !== undefined &&
+        choices.workspaceId !== existingConfig.workspaceId) {
+        return failure('invalid', diagnosticCodes.initInvalidInput, 'Reconfiguration cannot change workspaceId; the existing workspace identity is stable.', context.diagnostics, 'Remove the conflicting workspaceId from the reconfiguration selections, or create a new workspace separately.');
+    }
     const existingMachine = context.machineInspection.value;
     const diagnostics = [...context.diagnostics];
     const runtimeVersion = options.runtimeVersion ??
@@ -814,6 +1382,11 @@ export async function planWorkspaceInit(options) {
     let needWorkspaceConfig = false;
     let needMachineConfig = false;
     let selected = [];
+    let explicitPathSelections = {
+        repositories: new Map(),
+        knowledgeSources: new Map(),
+        observations: [],
+    };
     if (existingConfig !== null && options.reconfigure !== true) {
         config = existingConfig;
         if (choices !== null) {
@@ -839,7 +1412,19 @@ export async function planWorkspaceInit(options) {
         const effectiveChoices = existingConfig !== null && choices.workspaceId === undefined
             ? { ...choices, workspaceId: existingConfig.workspaceId }
             : choices;
-        const built = buildWorkspaceConfig(context.root, effectiveChoices, context.discovery, runtimeVersion);
+        const explicitPaths = await inspectExplicitInitPathSelections(context.root, effectiveChoices, context.discovery, existingConfig, options.pathObservations ?? []);
+        if (!explicitPaths.ok) {
+            return failureFromDiagnostics(explicitPaths.status, explicitPaths.diagnostics, diagnosticCodes.initInvalidInput, 'Explicit init paths could not be inspected safely.');
+        }
+        explicitPathSelections = explicitPaths.value;
+        const built = buildWorkspaceConfig(context.root, effectiveChoices, context.discovery, runtimeVersion, {
+            ...(existingConfig === null ? {} : { preserveFrom: existingConfig }),
+            ...(options.reconfigure === true
+                ? { strictExistingValidation: true }
+                : {}),
+            explicitRepositories: explicitPaths.value.repositories,
+            explicitKnowledgeSources: explicitPaths.value.knowledgeSources,
+        });
         diagnostics.push(...built.diagnostics);
         if (built.config === null) {
             return failureFromDiagnostics('invalid', diagnostics, diagnosticCodes.initInvalidInput, 'Init selections do not form a valid workspace configuration.');
@@ -848,8 +1433,21 @@ export async function planWorkspaceInit(options) {
         selected = built.selected;
         needWorkspaceConfig = true;
         if (existingMachine !== null) {
-            machine = existingMachine;
-            diagnostics.push(info(diagnosticCodes.initExistingConfigReused, 'Existing valid machine.json is reused while workspace.json is created.', context.machineInspection.path, 'Use a future configure flow to change local host or external repository mappings.'));
+            const desiredHosts = [
+                ...new Set(choices.hosts),
+            ];
+            const hostsChanged = desiredHosts.length !== existingMachine.selectedHosts.length ||
+                desiredHosts.some((host) => !existingMachine.selectedHosts.includes(host));
+            if (options.reconfigure === true &&
+                existingConfig !== null &&
+                hostsChanged) {
+                machine = { ...existingMachine, selectedHosts: desiredHosts };
+                needMachineConfig = true;
+            }
+            else {
+                machine = existingMachine;
+                diagnostics.push(info(diagnosticCodes.initExistingConfigReused, 'Existing valid machine.json is reused while workspace.json is created.', context.machineInspection.path, 'Use a future configure flow to change local host or external repository mappings.'));
+            }
         }
         else {
             needMachineConfig = true;
@@ -888,6 +1486,10 @@ export async function planWorkspaceInit(options) {
             ? {}
             : { discoveredAt: options.discoveredAt }),
     });
+    const pathRevalidation = await revalidateExplicitInitPaths(context.root, explicitPathSelections.observations, config.excludes);
+    if (pathRevalidation.length > 0) {
+        return failureFromDiagnostics('conflict', [...diagnostics, ...pathRevalidation], diagnosticCodes.initPlanStale, 'An explicitly added path changed while init was planning.');
+    }
     const finalWorkspace = await inspectWorkspaceConfig(context.root, {
         missing: 'info',
     });
@@ -905,7 +1507,7 @@ export async function planWorkspaceInit(options) {
     }
     const rootIdentity = context.rootIdentity;
     const scopeRepos = existingConfig !== null
-        ? scopeRepositories(config, context.discovery)
+        ? scopeRepositories(config, context.discovery, selected)
         : selected.map((repository) => ({
             id: repository.id,
             path: repository.path,
@@ -1112,7 +1714,7 @@ async function cleanupCreatedFiles(root, created) {
     return residual;
 }
 /**
- * Applies only create operations from a plan, after revalidating root,
+ * Applies create and managed replacement operations from a plan, after revalidating root,
  * configuration digest, target absence and exact bytes. External actions are
  * reported as pending and never executed here.
  */
@@ -1213,17 +1815,47 @@ export async function applyInitPlan(bundle, options = {}) {
         }
     };
     const restoreReplacements = async () => {
+        const residual = [];
+        const entries = originalManifest === null ? [] : [...originalManifest.entries];
         for (const replacement of [...replacements].reverse()) {
             try {
-                await writeFile(replacement.absolutePath, replacement.beforeBytes);
+                const current = await observePath(replacement.absolutePath);
+                if (current.kind !== 'file' ||
+                    current.stats === null ||
+                    current.stats.dev !== replacement.identity.dev ||
+                    current.stats.ino !== replacement.identity.ino ||
+                    sha256Digest(await readFile(replacement.absolutePath)) !==
+                        replacement.afterDigest) {
+                    residual.push(replacement.path);
+                    continue;
+                }
+                const restored = await writeBytesAtomic(replacement.absolutePath, replacement.beforeBytes, root);
+                if (!restored.ok)
+                    throw new Error(restored.message);
+                const after = await observePath(replacement.absolutePath);
+                if (after.kind !== 'file' || after.stats === null)
+                    throw new Error('Restored file is unreadable.');
+                const index = entries.findIndex((entry) => entry.path === replacement.path);
+                if (index >= 0)
+                    entries[index] = {
+                        ...entries[index],
+                        afterDigest: replacement.backupDigest,
+                        identity: { dev: after.stats.dev, ino: after.stats.ino },
+                    };
             }
             catch {
-                // The residual list below and the failure diagnostic report this case.
+                residual.push(replacement.path);
             }
         }
-        if (originalManifest !== null) {
-            await writeWorkspaceManifest(root, originalManifest).catch(() => undefined);
+        if (originalManifest !== null && replacements.length > 0) {
+            const restored = await writeWorkspaceManifest(root, {
+                ...originalManifest,
+                entries,
+            }).catch(() => ({ ok: false }));
+            if (!restored.ok)
+                residual.push('.pappra/local/install-manifest.json');
         }
+        return residual;
     };
     const rootBeforeWrite = await observePath(root);
     if (rootBeforeWrite.kind !== 'directory' ||
@@ -1233,13 +1865,38 @@ export async function applyInitPlan(bundle, options = {}) {
         return applyFailure('stale', diagnosticCodes.initPlanStale, 'Workspace root identity changed before writing.', 'Retry init from the current workspace root; no files were written.');
     }
     try {
+        if (bundle.plan.files.length > 0) {
+            const managedStart = await beginManagedApply(root, bundle.plan, bundle.writes, bundle.rootIdentity);
+            if (!managedStart.ok) {
+                return {
+                    ok: false,
+                    status: managedStart.status === 'invalid'
+                        ? 'stale'
+                        : managedStart.status === 'locked'
+                            ? 'conflict'
+                            : 'failed',
+                    appliedFiles: [],
+                    pendingExternalActions: [],
+                    residualPaths: managedStart.residualPaths,
+                    diagnostics: managedStart.diagnostics,
+                };
+            }
+            managed = managedStart.context;
+            originalManifest = managed.manifest;
+        }
+        else {
+            const ready = await verifyWorkspaceInstallReady(root);
+            if (!ready.ok)
+                return applyFailure('conflict', ready.code, ready.message, ready.nextAction ?? 'Run pappra repair before retrying init.');
+        }
         for (const index of replaceIndexes) {
             const file = bundle.plan.files[index];
             const write = bundle.writes[index];
             await options.beforeWrite?.(file.path, index);
             const absolutePath = resolvePortableRelativePath(root, file.path);
-            const backupRef = backupPath(root, bundle.plan.planId, file.path);
-            const stateBoundary = await ensureStatePathBoundary(root, backupRef);
+            const backupFile = backupPath(root, managed.installId, file.path);
+            const backupRef = toWorkspaceRelativePath(root, backupFile);
+            const stateBoundary = await ensureStatePathBoundary(root, backupFile);
             if (!stateBoundary.ok)
                 throw new Error(stateBoundary.message);
             const beforeBytes = await readFile(absolutePath);
@@ -1248,12 +1905,33 @@ export async function applyInitPlan(bundle, options = {}) {
                 throw new Error(`Replacement target changed again: ${file.path}`);
             }
             const observation = await observePath(absolutePath);
+            if (observation.kind !== 'file')
+                throw new Error(`Unsafe replacement target: ${file.path}`);
             const mode = observation.stats === null ? 0o644 : observation.stats.mode & 0o777;
-            await mkdir(dirname(backupRef), { recursive: true });
-            await writeFile(backupRef, beforeBytes, { mode: 0o600, flag: 'wx' });
+            await mkdir(dirname(backupFile), { recursive: true });
+            await writeFile(backupFile, beforeBytes, { mode: 0o600, flag: 'wx' });
             const temporary = `${absolutePath}.pappra-replace-${randomUUID().slice(0, 8)}`;
-            await writeFile(temporary, write.bytes, { mode });
-            await rename(temporary, absolutePath);
+            try {
+                await writeFile(temporary, write.bytes, { mode, flag: 'wx' });
+                const staged = await observePath(temporary);
+                if (staged.kind !== 'file' || staged.stats === null)
+                    throw new Error('Replacement staging failed.');
+                const recorded = await recordManagedFile(managed, file.path, file.nextDigest, { dev: staged.stats.dev, ino: staged.stats.ino }, { backupRef, backupDigest: sha256Digest(beforeBytes) });
+                if (!recorded.ok)
+                    throw new Error(recorded.diagnostics[0]?.message ?? 'Cannot journal replacement.');
+                const beforeRename = await observePath(absolutePath);
+                if (beforeRename.kind !== 'file' ||
+                    beforeRename.stats?.dev !== observation.stats?.dev ||
+                    beforeRename.stats?.ino !== observation.stats?.ino ||
+                    sha256Digest(await readFile(absolutePath)) !==
+                        file.expectedBeforeDigest) {
+                    throw new Error(`Replacement target changed before publish: ${file.path}`);
+                }
+                await rename(temporary, absolutePath);
+            }
+            finally {
+                await rm(temporary, { force: true }).catch(() => undefined);
+            }
             const after = await observePath(absolutePath);
             if (after.kind !== 'file' || after.stats === null) {
                 throw new Error(`Replacement target is unreadable after writing: ${file.path}`);
@@ -1268,68 +1946,7 @@ export async function applyInitPlan(bundle, options = {}) {
                 identity: { dev: after.stats.dev, ino: after.stats.ino },
             });
         }
-        if (replacements.length > 0) {
-            const manifestRead = await readWorkspaceManifest(root);
-            if (manifestRead.diagnostics.length > 0) {
-                throw new Error(manifestRead.diagnostics[0]?.message ??
-                    'Workspace install manifest is unreadable.');
-            }
-            if (manifestRead.value === null) {
-                throw new Error('Workspace install manifest is missing; Pappra does not adopt an unowned replacement.');
-            }
-            originalManifest = manifestRead.value;
-            const entries = [...manifestRead.value.entries];
-            const verifiedAt = new Date().toISOString();
-            for (const replacement of replacements) {
-                const entry = {
-                    path: replacement.path,
-                    installId: bundle.plan.planId,
-                    operation: 'replace-managed',
-                    beforeDigest: replacement.backupDigest,
-                    afterDigest: replacement.afterDigest,
-                    backupRef: replacement.backupRef,
-                    backupDigest: replacement.backupDigest,
-                    identity: replacement.identity,
-                    owner: 'pappra',
-                    verifiedAt,
-                };
-                const existingIndex = entries.findIndex((item) => item.path === replacement.path);
-                if (existingIndex === -1)
-                    entries.push(entry);
-                else
-                    entries[existingIndex] = entry;
-            }
-            const written = await writeWorkspaceManifest(root, {
-                ...manifestRead.value,
-                entries,
-            });
-            if (!written.ok)
-                throw new Error(written.message);
-        }
         if (createIndexes.length > 0) {
-            const createPlan = {
-                ...bundle.plan,
-                files: createIndexes.map((index) => bundle.plan.files[index]),
-            };
-            const createWrites = createIndexes.map((index) => bundle.writes[index]);
-            const managedStart = await beginManagedApply(root, createPlan, createWrites, bundle.rootIdentity);
-            if (!managedStart.ok) {
-                const status = managedStart.status === 'invalid'
-                    ? 'stale'
-                    : managedStart.status === 'locked'
-                        ? 'conflict'
-                        : 'failed';
-                await restoreReplacements();
-                return {
-                    ok: false,
-                    status,
-                    appliedFiles: [],
-                    pendingExternalActions: [],
-                    residualPaths: managedStart.residualPaths,
-                    diagnostics: managedStart.diagnostics,
-                };
-            }
-            managed = managedStart.context;
             for (const index of createIndexes) {
                 const file = bundle.plan.files[index];
                 const write = bundle.writes[index];
@@ -1356,17 +1973,22 @@ export async function applyInitPlan(bundle, options = {}) {
                 finally {
                     await handle.close();
                 }
+                await options.afterWrite?.(file.path, index);
                 created.push(record);
                 const recorded = await recordManagedFile(managed, file.path, file.nextDigest, { dev: record.dev, ino: record.ino });
                 if (!recorded.ok) {
                     throw new Error(recorded.diagnostics[0]?.message ?? `Cannot record ${file.path}.`);
                 }
             }
+        }
+        if (managed !== null) {
             const completed = await completeManagedApply(managed);
             if (!completed.ok) {
-                const residual = await cleanupCreatedFiles(root, created);
+                const residual = [
+                    ...(await cleanupCreatedFiles(root, created)),
+                    ...(await restoreReplacements()),
+                ];
                 const failed = await failManagedApply(managed, 'Cannot finalize managed installation manifest.', residual);
-                await restoreReplacements();
                 return {
                     ok: false,
                     status: 'failed',
@@ -1395,8 +2017,10 @@ export async function applyInitPlan(bundle, options = {}) {
         };
     }
     catch (error) {
-        await restoreReplacements();
-        const residual = await cleanupCreatedFiles(root, created);
+        const residual = [
+            ...(await restoreReplacements()),
+            ...(await cleanupCreatedFiles(root, created)),
+        ];
         for (const directory of createdDirectories.reverse()) {
             await rmdir(directory).catch(() => undefined);
         }
@@ -1494,24 +2118,13 @@ export async function bindAndRecordRuntime(root, installed) {
     };
 }
 /**
- * Converges the runtime binding by installing a durable copy of the package that
- * is currently executing. Reusing an already verified copy is cheap: the install
- * machinery short-circuits before packing.
+ * Ensures and binds the runtime package that is currently executing.
+ *
+ * The installer reuses an existing runtime only after its manifest, package
+ * contents, executable and smoke checks pass; a regular file is not proof of a
+ * verified durable runtime.
  */
 export async function ensureDefaultRuntime(root, targetVersion) {
-    const machine = await inspectMachineConfig(root);
-    const binding = machine.value?.runtime ?? null;
-    if (binding !== null && binding.version === targetVersion) {
-        const executable = await observePath(binding.executable);
-        if (executable.kind === 'file') {
-            return {
-                ok: true,
-                completion: true,
-                runtime: null,
-                diagnostics: [],
-            };
-        }
-    }
     const installed = await installRuntime({
         version: targetVersion,
         source: { kind: 'self', path: getPackageRoot() },