sdd-mcp-server 4.0.0 → 5.0.0

package/dist/cli/utils/preserving-writer.js

@@ -1,11 +1,11 @@
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
-import { setTimeout as delay } from 'timers/promises';
+import { INSTALL_MANIFEST_SCHEMA_VERSION, INSTALL_RENDERER_VERSION, PACKAGE_VERSION } from '../../shared/version.js';
 import { atomicWriteFile } from '../../utils/atomicWrite.js';
-const MANIFEST_SCHEMA_VERSION = 1;
-const RENDERER_VERSION = 4;
-const PACKAGE_VERSION = '4.0.0';
+import { withFilesystemLock } from '../../utils/withFilesystemLock.js';
+import { getTargetPolicy, } from '../install-target.js';
+import { registerRuntimeLocked, } from '../tool-support/mcp-registration.js';
 /** Explicit v3.5.1 package-owned files which v4 no longer renders. */
 export const LEGACY_V351_TOMBSTONES = {
     'claude-code': ['.claude/rules/git-workflow.md', '.claude/rules/sdd-workflow.md'],
@@ -50,16 +50,92 @@ export class PreservingWriter {
     selectedComponents = new Map();
     refreshTargets = new Set();
     pendingShared = new Map();
+    runtimePaths = new Map();
+    runtimeResults = new Map();
+    activeLeaseAssert;
+    pendingWrites = new Map();
+    committedTargets = new Set();
+    preservedModifiedFiles = new Map();
     backupStamp;
     constructor(projectRoot) {
         this.projectRoot = projectRoot;
     }
     beginTarget(target, profile, components, refreshGenerated = false) {
         this.generated.set(target, new Map());
+        this.preservedModifiedFiles.set(target, new Set());
+        this.committedTargets.delete(target);
+        this.runtimeResults.delete(target);
         this.profiles.set(target, profile);
         this.selectedComponents.set(target, new Set([...components, 'root']));
         if (refreshGenerated)
             this.refreshTargets.add(target);
+        else
+            this.refreshTargets.delete(target);
+    }
+    async withInstallLock(action) {
+        if (this.activeLeaseAssert)
+            return action();
+        const lockPath = path.join(this.projectRoot, '.sdd-mcp', 'install.lock');
+        this.validateDestination(lockPath);
+        await fs.promises.mkdir(path.dirname(lockPath), { recursive: true });
+        this.validateDestination(lockPath);
+        const committedBefore = new Set(this.committedTargets);
+        let completed = false;
+        let value;
+        try {
+            return await withFilesystemLock(lockPath, async (lease) => {
+                this.activeLeaseAssert = lease.assertHeld;
+                try {
+                    value = await action();
+                    completed = true;
+                    return value;
+                }
+                finally {
+                    this.activeLeaseAssert = undefined;
+                }
+            });
+        }
+        catch (error) {
+            const committedDuringAction = [...this.committedTargets]
+                .filter((target) => !committedBefore.has(target));
+            if (!completed || committedDuringAction.length === 0)
+                throw error;
+            const warning = `Installation committed, but install lock release reported an error: ${error instanceof Error ? error.message : String(error)}`;
+            for (const target of committedDuringAction) {
+                const result = this.runtimeResults.get(target);
+                if (result && !result.warnings.includes(warning))
+                    result.warnings.push(warning);
+            }
+            if (value && typeof value === 'object' && 'warnings' in value) {
+                const warnings = value.warnings;
+                if (Array.isArray(warnings) && !warnings.includes(warning))
+                    warnings.push(warning);
+            }
+            return value;
+        }
+    }
+    requireRuntimeRegistration(target, paths) {
+        this.runtimePaths.set(target, paths);
+    }
+    takeRuntimeResult(target) {
+        return this.runtimeResults.get(target) ?? { installed: [], skipped: [], warnings: [] };
+    }
+    async rollbackUncommitted(target, assertHeld = this.activeLeaseAssert) {
+        const writes = this.pendingWrites.get(target);
+        if (!writes)
+            return;
+        const leaseAssert = assertHeld ?? (async () => undefined);
+        for (const [filePath, snapshot] of [...writes].reverse()) {
+            if (snapshot.prior === null) {
+                if (snapshot.next !== null) {
+                    await this.removeBytesCas(filePath, snapshot.next, leaseAssert);
+                }
+            }
+            else {
+                await this.replaceBytesCas(filePath, snapshot.next, snapshot.prior, leaseAssert);
+            }
+        }
+        this.pendingWrites.delete(target);
     }
     async writeManaged(target, component, name, filePath, content) {
         this.validateDestination(filePath);
@@ -69,7 +145,8 @@ export class PreservingWriter {
         const exists = await pathExists(filePath);
         if (component === 'steering') {
             if (!exists) {
-                await atomicWriteFile(filePath, content);
+                this.trackPendingWrite(target, filePath, null, Buffer.from(content));
+                await this.replaceManagedBytesCas(filePath, null, Buffer.from(content));
                 this.pendingShared.set(relative, { sha256: desiredHash, component: 'steering', mutable: true });
                 return { outcome: 'installed' };
             }
@@ -77,25 +154,38 @@ export class PreservingWriter {
             this.pendingShared.set(relative, { sha256: existingHash, component: 'steering', mutable: true });
             return { outcome: 'skipped' };
         }
-        this.generatedFor(target).set(relative, { sha256: desiredHash, component });
+        const generated = this.generatedFor(target);
         const prior = manifest.targets[target]?.files[relative];
         if (!exists) {
-            await atomicWriteFile(filePath, content);
+            generated.set(relative, { sha256: desiredHash, component });
+            this.trackPendingWrite(target, filePath, null, Buffer.from(content));
+            await this.replaceManagedBytesCas(filePath, null, Buffer.from(content));
             return { outcome: 'installed' };
         }
         const existing = await fs.promises.readFile(filePath, 'utf8');
         const existingHash = sha256(existing);
-        if (existingHash === desiredHash)
+        if (existingHash === desiredHash) {
+            generated.set(relative, { sha256: desiredHash, component });
             return { outcome: 'skipped' };
+        }
         if (this.refreshTargets.has(target)) {
+            generated.set(relative, { sha256: desiredHash, component });
+            this.trackPendingWrite(target, filePath, Buffer.from(existing), Buffer.from(content));
+            await this.activeLeaseAssert?.();
             await this.backup(target, relative, filePath);
-            await atomicWriteFile(filePath, content);
+            await this.replaceManagedBytesCas(filePath, Buffer.from(existing), Buffer.from(content));
             return { outcome: 'installed' };
         }
         if (prior && existingHash === prior.sha256) {
-            await atomicWriteFile(filePath, content);
+            generated.set(relative, { sha256: desiredHash, component });
+            this.trackPendingWrite(target, filePath, Buffer.from(existing), Buffer.from(content));
+            await this.replaceManagedBytesCas(filePath, Buffer.from(existing), Buffer.from(content));
             return { outcome: 'installed' };
         }
+        if (prior) {
+            generated.set(relative, prior);
+            this.preservedModifiedFiles.get(target)?.add(relative);
+        }
         return {
             outcome: 'skipped',
             conflict: {
@@ -106,68 +196,167 @@ export class PreservingWriter {
             },
         };
     }
+    async installRuntimeRegistration(target, paths = getTargetPolicy(target).defaultPaths) {
+        return this.withInstallLock(async () => {
+            const assertHeld = this.requireActiveLease();
+            const manifestSnapshot = await this.readManifestSnapshot();
+            const manifest = manifestSnapshot.manifest;
+            const previous = manifest.targets[target];
+            const runtime = await registerRuntimeLocked(this.projectRoot, target, paths, previous?.registrations[0], assertHeld);
+            const latest = manifest;
+            latest.targets[target] = {
+                profile: previous?.profile ?? 'lean',
+                packageVersion: PACKAGE_VERSION,
+                rendererVersion: INSTALL_RENDERER_VERSION,
+                files: previous?.files ?? {},
+                registrations: [runtime.registration],
+            };
+            const priorManifestBytes = manifestSnapshot.bytes;
+            const nextManifestBytes = Buffer.from(`${JSON.stringify(latest, null, 2)}\n`);
+            try {
+                await runtime.verify();
+                await this.replaceBytesCas(this.manifestPath, priorManifestBytes, nextManifestBytes, assertHeld);
+            }
+            catch (error) {
+                const currentManifestBytes = await readOptionalBytes(this.manifestPath);
+                if (buffersEqual(currentManifestBytes, nextManifestBytes)) {
+                    this.markTargetCommitted(target);
+                    return {
+                        installed: runtime.installed,
+                        skipped: runtime.skipped,
+                        warnings: [`Runtime registration committed, but manifest write reported an error: ${error instanceof Error ? error.message : String(error)}`],
+                    };
+                }
+                if (buffersEqual(currentManifestBytes, priorManifestBytes)) {
+                    await runtime.rollback();
+                    throw error;
+                }
+                throw new Error('Install manifest changed to unknown bytes; runtime partials were preserved');
+            }
+            this.markTargetCommitted(target);
+            return { installed: runtime.installed, skipped: runtime.skipped, warnings: [] };
+        });
+    }
     async finalizeTarget(target) {
         this.validateDestination(this.manifestPath);
-        return withManifestLock(this.projectRoot, async () => {
-            const conflicts = [];
-            const manifest = await this.readManifest();
-            const previous = manifest.targets[target]?.files ?? {};
-            const generated = this.generatedFor(target);
-            const selected = this.selectedComponents.get(target) ?? new Set();
-            for (const [relative, record] of Object.entries(previous)) {
-                if (generated.has(relative) || !selected.has(record.component))
+        return this.withInstallLock(async () => this.finalizeTargetLocked(target, this.requireActiveLease()));
+    }
+    async finalizeTargetLocked(target, assertHeld) {
+        try {
+            return await this.commitTargetLocked(target, assertHeld);
+        }
+        catch (error) {
+            await this.rollbackUncommitted(target, assertHeld);
+            throw error;
+        }
+    }
+    async commitTargetLocked(target, assertHeld) {
+        const conflicts = [];
+        const manifestSnapshot = await this.readManifestSnapshot();
+        const manifest = manifestSnapshot.manifest;
+        const previousTarget = manifest.targets[target];
+        const previous = previousTarget?.files ?? {};
+        const generated = this.generatedFor(target);
+        const selected = this.selectedComponents.get(target) ?? new Set();
+        for (const [relative, record] of Object.entries(previous)) {
+            if (generated.has(relative) || !selected.has(record.component))
+                continue;
+            const destination = path.join(this.projectRoot, relative);
+            if (!await pathExists(destination))
+                continue;
+            this.validateDestination(destination);
+            const currentBytes = await fs.promises.readFile(destination);
+            const currentHash = sha256(currentBytes);
+            if (currentHash !== record.sha256 && !this.refreshTargets.has(target)) {
+                conflicts.push({
+                    component: record.component,
+                    name: path.basename(relative),
+                    path: destination,
+                    reason: 'obsolete-modified',
+                });
+                continue;
+            }
+            this.trackPendingWrite(target, destination, currentBytes, null);
+            await assertHeld();
+            await this.backup(target, relative, destination);
+            await this.removeBytesCas(destination, currentBytes, assertHeld);
+        }
+        if (this.refreshTargets.has(target)) {
+            for (const relative of LEGACY_V351_TOMBSTONES[target]) {
+                if (generated.has(relative))
                     continue;
                 const destination = path.join(this.projectRoot, relative);
                 if (!await pathExists(destination))
                     continue;
                 this.validateDestination(destination);
-                const currentHash = sha256(await fs.promises.readFile(destination));
-                if (currentHash !== record.sha256 && !this.refreshTargets.has(target)) {
-                    conflicts.push({
-                        component: record.component,
-                        name: path.basename(relative),
-                        path: destination,
-                        reason: 'obsolete-modified',
-                    });
-                    continue;
-                }
+                const currentBytes = await fs.promises.readFile(destination);
+                this.trackPendingWrite(target, destination, currentBytes, null);
+                await assertHeld();
                 await this.backup(target, relative, destination);
-                await fs.promises.rm(destination, { force: true });
+                await this.removeBytesCas(destination, currentBytes, assertHeld);
             }
-            if (this.refreshTargets.has(target)) {
-                for (const relative of LEGACY_V351_TOMBSTONES[target]) {
-                    if (generated.has(relative))
-                        continue;
-                    const destination = path.join(this.projectRoot, relative);
-                    if (!await pathExists(destination))
-                        continue;
-                    this.validateDestination(destination);
-                    await this.backup(target, relative, destination);
-                    await fs.promises.rm(destination, { force: true });
-                }
+        }
+        const runtimePaths = this.runtimePaths.get(target) ?? getTargetPolicy(target).defaultPaths;
+        const runtime = await registerRuntimeLocked(this.projectRoot, target, runtimePaths, previousTarget?.registrations[0], assertHeld);
+        const retainedUnselected = Object.fromEntries(Object.entries(previous).filter(([, record]) => !selected.has(record.component)));
+        const latest = manifest;
+        latest.targets[target] = {
+            profile: this.profiles.get(target) ?? 'lean',
+            packageVersion: PACKAGE_VERSION,
+            rendererVersion: INSTALL_RENDERER_VERSION,
+            files: { ...retainedUnselected, ...Object.fromEntries(generated) },
+            registrations: [runtime.registration],
+        };
+        Object.assign(latest.shared, Object.fromEntries(this.pendingShared));
+        const priorManifestBytes = manifestSnapshot.bytes;
+        const nextManifestBytes = Buffer.from(`${JSON.stringify(latest, null, 2)}\n`);
+        try {
+            await this.verifyPendingOwnership(target, generated, assertHeld);
+            await runtime.verify();
+            await this.replaceBytesCas(this.manifestPath, priorManifestBytes, nextManifestBytes, assertHeld);
+        }
+        catch (error) {
+            const currentManifestBytes = await readOptionalBytes(this.manifestPath);
+            if (buffersEqual(currentManifestBytes, nextManifestBytes)) {
+                this.runtimeResults.set(target, {
+                    installed: runtime.installed,
+                    skipped: runtime.skipped,
+                    warnings: [`Installation committed, but manifest write reported an error: ${error instanceof Error ? error.message : String(error)}`],
+                });
+                this.markTargetCommitted(target);
+                return conflicts;
             }
-            const latest = await this.readManifest();
-            latest.targets[target] = {
-                profile: this.profiles.get(target) ?? 'lean',
-                packageVersion: PACKAGE_VERSION,
-                rendererVersion: RENDERER_VERSION,
-                files: Object.fromEntries(generated),
-            };
-            Object.assign(latest.shared, Object.fromEntries(this.pendingShared));
-            await atomicWriteFile(this.manifestPath, `${JSON.stringify(latest, null, 2)}\n`);
-            return conflicts;
+            if (buffersEqual(currentManifestBytes, priorManifestBytes)) {
+                await runtime.rollback();
+                throw error;
+            }
+            this.pendingWrites.delete(target);
+            throw new Error('Install manifest changed to unknown bytes; installer partials were preserved');
+        }
+        this.runtimeResults.set(target, {
+            installed: runtime.installed,
+            skipped: runtime.skipped,
+            warnings: [],
         });
+        this.markTargetCommitted(target);
+        return conflicts;
     }
     async recordShared(filePath, component, mutable) {
         this.validateDestination(filePath);
         if (!await pathExists(filePath))
             return;
         const relative = this.relative(filePath);
-        const digest = sha256(await fs.promises.readFile(filePath));
-        await withManifestLock(this.projectRoot, async () => {
-            const manifest = await this.readManifest();
-            manifest.shared[relative] = { sha256: digest, component, mutable };
-            await atomicWriteFile(this.manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+        await this.withInstallLock(async () => {
+            const assertHeld = this.requireActiveLease();
+            const snapshot = await this.readManifestSnapshot();
+            const content = await readOptionalBytes(filePath);
+            if (content === null)
+                return;
+            const record = { sha256: sha256(content), component, mutable };
+            snapshot.manifest.shared[relative] = record;
+            const next = Buffer.from(`${JSON.stringify(snapshot.manifest, null, 2)}\n`);
+            await this.verifyOwnedFile(relative, record.sha256);
+            await this.replaceBytesCas(this.manifestPath, snapshot.bytes, next, assertHeld);
         });
     }
     async writeIfAbsent(filePath, content) {
@@ -232,78 +421,260 @@ export class PreservingWriter {
         await fs.promises.mkdir(path.dirname(destination), { recursive: true });
         await fs.promises.copyFile(source, destination);
     }
+    async verifyPendingOwnership(target, generated, assertHeld) {
+        const preservedModified = this.preservedModifiedFiles.get(target);
+        for (const [relative, record] of generated) {
+            if (preservedModified?.has(relative))
+                continue;
+            await this.verifyOwnedFile(relative, record.sha256);
+        }
+        for (const [relative, record] of this.pendingShared) {
+            await this.verifyOwnedFile(relative, record.sha256);
+        }
+        await assertHeld();
+    }
+    async verifyOwnedFile(relative, expectedSha256) {
+        const destination = path.resolve(this.projectRoot, relative);
+        this.validateDestination(destination);
+        const current = await readOptionalBytes(destination);
+        if (current === null || sha256(current) !== expectedSha256) {
+            throw new Error(`Managed file changed before manifest commit: ${relative}`);
+        }
+    }
     get manifestPath() {
         return path.join(this.projectRoot, '.sdd-mcp', 'install-manifest.json');
     }
     async readManifest() {
-        try {
-            const parsed = JSON.parse(await fs.promises.readFile(this.manifestPath, 'utf8'));
-            if (parsed.schemaVersion !== MANIFEST_SCHEMA_VERSION || !parsed.targets || !parsed.shared) {
-                throw new Error('Unsupported install manifest schema');
+        return (await this.readManifestSnapshot()).manifest;
+    }
+    async readManifestSnapshot() {
+        this.validateDestination(this.manifestPath);
+        const bytes = await readOptionalBytes(this.manifestPath);
+        return {
+            bytes,
+            manifest: bytes === null
+                ? { schemaVersion: INSTALL_MANIFEST_SCHEMA_VERSION, targets: {}, shared: {} }
+                : this.parseManifest(bytes),
+        };
+    }
+    parseManifest(bytes) {
+        const value = JSON.parse(bytes.toString('utf8'));
+        const parsed = this.requireManifestRecord(value, 'Unsupported install manifest schema');
+        if (!hasOnlyKeys(parsed, ['schemaVersion', 'targets', 'shared']) || (parsed.schemaVersion !== 1 && parsed.schemaVersion !== INSTALL_MANIFEST_SCHEMA_VERSION))
+            throw new Error('Unsupported install manifest schema');
+        const targetsRaw = this.requireManifestRecord(parsed.targets, 'Unsupported install manifest schema');
+        const sharedRaw = this.requireManifestRecord(parsed.shared, 'Unsupported install manifest schema');
+        const targets = Object.create(null);
+        for (const [targetName, targetValue] of Object.entries(targetsRaw)) {
+            if (!isInstallTarget(targetName))
+                throw new Error('Invalid install manifest target');
+            const target = this.requireManifestRecord(targetValue, 'Invalid install manifest ownership entry');
+            if (!hasOnlyKeys(target, ['profile', 'packageVersion', 'rendererVersion', 'files', 'registrations'])) {
+                throw new Error('Invalid install manifest target metadata');
+            }
+            if ((target.profile !== 'lean' && target.profile !== 'full')
+                || typeof target.packageVersion !== 'string'
+                || target.packageVersion.length === 0
+                || !Number.isInteger(target.rendererVersion)
+                || target.rendererVersion < 1) {
+                throw new Error('Invalid install manifest target metadata');
             }
-            return parsed;
+            const filesRaw = this.requireManifestRecord(target.files, 'Invalid install manifest ownership entry');
+            const files = Object.create(null);
+            for (const [relativePath, fileValue] of Object.entries(filesRaw)) {
+                this.validateManifestRelativePath(relativePath);
+                const record = this.requireManifestRecord(fileValue, 'Invalid install manifest ownership entry');
+                if (!hasOnlyKeys(record, ['sha256', 'component']) || !isSha256(record.sha256) || !isManifestComponent(record.component)) {
+                    throw new Error('Invalid install manifest ownership entry');
+                }
+                files[relativePath] = { sha256: record.sha256, component: record.component };
+            }
+            if (parsed.schemaVersion === 1 && target.registrations !== undefined) {
+                throw new Error('Invalid install manifest registration entry');
+            }
+            let registrations = [];
+            if (parsed.schemaVersion !== 1) {
+                if (!Array.isArray(target.registrations) || target.registrations.length > 1) {
+                    throw new Error('Invalid install manifest registration entry');
+                }
+                registrations = target.registrations.map((registrationValue) => {
+                    const registration = this.requireManifestRecord(registrationValue, 'Invalid install manifest registration entry');
+                    if (!hasOnlyKeys(registration, [
+                        'path',
+                        'serverName',
+                        'entrySemanticSha256',
+                        'managedRegionSha256',
+                        'permissionPath',
+                        'permissionSemanticSha256',
+                    ])) {
+                        throw new Error('Invalid install manifest registration entry');
+                    }
+                    if (registration.serverName !== 'sdd-mcp'
+                        || !isSha256(registration.entrySemanticSha256)
+                        || (registration.managedRegionSha256 !== undefined
+                            && !isSha256(registration.managedRegionSha256))
+                        || (registration.permissionSemanticSha256 !== undefined
+                            && !isSha256(registration.permissionSemanticSha256))) {
+                        throw new Error('Invalid install manifest registration entry');
+                    }
+                    const registrationPath = this.requireManifestRelativePath(registration.path);
+                    const permissionPath = registration.permissionPath === undefined
+                        ? undefined
+                        : this.requireManifestRelativePath(registration.permissionPath);
+                    if (registration.permissionSemanticSha256 !== undefined && permissionPath === undefined) {
+                        throw new Error('Invalid install manifest registration entry');
+                    }
+                    return {
+                        path: registrationPath,
+                        serverName: 'sdd-mcp',
+                        entrySemanticSha256: registration.entrySemanticSha256,
+                        managedRegionSha256: typeof registration.managedRegionSha256 === 'string'
+                            ? registration.managedRegionSha256
+                            : undefined,
+                        permissionPath,
+                        permissionSemanticSha256: typeof registration.permissionSemanticSha256 === 'string'
+                            ? registration.permissionSemanticSha256
+                            : undefined,
+                    };
+                });
+            }
+            targets[targetName] = {
+                profile: target.profile,
+                packageVersion: target.packageVersion,
+                rendererVersion: target.rendererVersion,
+                files,
+                registrations,
+            };
         }
-        catch (error) {
-            if (!isMissing(error))
-                throw error;
-            return { schemaVersion: MANIFEST_SCHEMA_VERSION, targets: {}, shared: {} };
+        const shared = Object.create(null);
+        for (const [relativePath, sharedValue] of Object.entries(sharedRaw)) {
+            this.validateManifestRelativePath(relativePath);
+            const record = this.requireManifestRecord(sharedValue, 'Invalid install manifest ownership entry');
+            if (!hasOnlyKeys(record, ['sha256', 'component', 'mutable'])
+                || !isSha256(record.sha256)
+                || (record.component !== 'steering' && record.component !== 'gitignore')
+                || typeof record.mutable !== 'boolean') {
+                throw new Error('Invalid install manifest ownership entry');
+            }
+            shared[relativePath] = {
+                sha256: record.sha256,
+                component: record.component,
+                mutable: record.mutable,
+            };
         }
+        return {
+            schemaVersion: INSTALL_MANIFEST_SCHEMA_VERSION,
+            targets,
+            shared,
+        };
+    }
+    requireManifestRecord(value, message) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error(message);
+        return value;
+    }
+    requireManifestRelativePath(value) {
+        if (typeof value !== 'string')
+            throw new Error('Invalid install manifest path');
+        this.validateManifestRelativePath(value);
+        return value;
+    }
+    validateManifestRelativePath(value) {
+        if (!value || value.includes('\\') || value.includes('\0')) {
+            throw new Error('Invalid install manifest path');
+        }
+        const destination = path.resolve(this.projectRoot, value);
+        this.validateDestination(destination);
+        if (this.relative(destination) !== value)
+            throw new Error('Invalid install manifest path');
+    }
+    async replaceManagedBytesCas(filePath, expected, desired) {
+        await this.replaceBytesCas(filePath, expected, desired, this.activeLeaseAssert ?? (async () => undefined));
+    }
+    async replaceBytesCas(filePath, expected, desired, assertHeld) {
+        await assertHeld();
+        const current = await readOptionalBytes(filePath);
+        if (!buffersEqual(current, expected)) {
+            if (buffersEqual(current, desired)) {
+                await assertHeld();
+                return;
+            }
+            throw new Error(`Concurrent installer state change at ${this.relative(filePath)}`);
+        }
+        await atomicWriteFile(filePath, desired.toString('utf8'));
+        if (!buffersEqual(await readOptionalBytes(filePath), desired)) {
+            throw new Error(`Installer write verification failed at ${this.relative(filePath)}`);
+        }
+        await assertHeld();
+    }
+    async removeBytesCas(filePath, expected, assertHeld) {
+        await assertHeld();
+        if (!buffersEqual(await readOptionalBytes(filePath), expected)) {
+            throw new Error(`Concurrent installer state change at ${this.relative(filePath)}`);
+        }
+        await fs.promises.rm(filePath, { force: true });
+        if (await readOptionalBytes(filePath) !== null) {
+            throw new Error(`Installer delete verification failed at ${this.relative(filePath)}`);
+        }
+        await assertHeld();
     }
     relative(filePath) {
         return path.relative(this.projectRoot, filePath).split(path.sep).join('/');
     }
+    trackPendingWrite(target, filePath, prior, next) {
+        let writes = this.pendingWrites.get(target);
+        if (!writes) {
+            writes = new Map();
+            this.pendingWrites.set(target, writes);
+        }
+        if (!writes.has(filePath))
+            writes.set(filePath, { prior, next });
+        else
+            writes.get(filePath).next = next;
+    }
+    markTargetCommitted(target) {
+        this.pendingWrites.delete(target);
+        this.committedTargets.add(target);
+    }
+    requireActiveLease() {
+        if (!this.activeLeaseAssert)
+            throw new Error('Installer lock lease is not active');
+        return this.activeLeaseAssert;
+    }
     validateDestination(destination) {
         validateDestinationPath(this.projectRoot, destination);
     }
 }
-const MANIFEST_LOCKS = new Map();
-async function withManifestLock(root, action) {
-    const key = path.resolve(root);
-    const previous = MANIFEST_LOCKS.get(key) ?? Promise.resolve();
-    const run = previous.catch(() => undefined).then(async () => {
-        const releaseFilesystemLock = await acquireFilesystemLock(root);
-        try {
-            return await action();
-        }
-        finally {
-            await releaseFilesystemLock();
-        }
-    });
-    const settled = run.then(() => undefined, () => undefined);
-    MANIFEST_LOCKS.set(key, settled);
+async function readOptionalBytes(filePath) {
     try {
-        return await run;
+        return await fs.promises.readFile(filePath);
     }
-    finally {
-        if (MANIFEST_LOCKS.get(key) === settled)
-            MANIFEST_LOCKS.delete(key);
+    catch (error) {
+        if (isMissing(error))
+            return null;
+        throw error;
     }
 }
-async function acquireFilesystemLock(root) {
-    const lockPath = path.join(root, '.sdd-mcp', 'install-manifest.lock');
-    validateDestinationPath(root, lockPath);
-    await fs.promises.mkdir(path.dirname(lockPath), { recursive: true });
-    for (let attempt = 0; attempt < 100; attempt += 1) {
-        try {
-            const handle = await fs.promises.open(lockPath, 'wx');
-            await handle.writeFile(`${process.pid}\n`);
-            await handle.close();
-            return async () => {
-                await fs.promises.rm(lockPath, { force: true });
-            };
-        }
-        catch (error) {
-            if (!isAlreadyExists(error))
-                throw error;
-            const stats = await fs.promises.stat(lockPath).catch(() => undefined);
-            if (stats && Date.now() - stats.mtimeMs > 30_000) {
-                await fs.promises.rm(lockPath, { force: true });
-                continue;
-            }
-            await delay(20);
-        }
-    }
-    throw new Error(`Timed out acquiring install manifest lock: ${lockPath}`);
+function buffersEqual(left, right) {
+    return left === null || right === null ? left === right : left.equals(right);
+}
+function hasOnlyKeys(record, allowed) {
+    return Object.keys(record).every((key) => allowed.includes(key));
+}
+function isInstallTarget(value) {
+    return value === 'claude-code' || value === 'codex' || value === 'omp';
+}
+function isManifestComponent(value) {
+    return value === 'root'
+        || value === 'skills'
+        || value === 'steering'
+        || value === 'rules'
+        || value === 'contexts'
+        || value === 'agents'
+        || value === 'hooks';
+}
+function isSha256(value) {
+    return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
 }
 function sha256(content) {
     return crypto.createHash('sha256').update(content).digest('hex');