@lesliechan721/aw 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/src/commands/rebuild-operations.js

@@ -1,11 +1,6 @@
 import path from 'node:path';
-import { acquireLifecycleOperationLock, discardLifecycleActiveSnapshot, leaseLifecycleActiveSnapshot, prepareLifecycleActiveSnapshot, promoteLifecycleActiveSnapshot, readLifecycleActiveSnapshot, releaseLifecycleActiveSnapshot, removeLifecycleActiveSnapshot, restoreLifecycleActiveScriptInputs, } from '../utils/lifecycle-active-store.js';
+import { readSafeOperationError } from '../utils/safe-operation-diagnostic.js';
 import { cleanupOwnedComponents, inspectOwnedComponents, validateOwnerIdentity, } from '../utils/ownership.js';
-async function withOwnershipLease(target, driver, operation) {
-    return driver.withOwnershipLease
-        ? driver.withOwnershipLease(target, operation)
-        : operation();
-}
 function artifactIdentity(artifact) {
     return [
         artifact.platform,
@@ -27,75 +22,6 @@ function bindWrittenArtifacts(target, written) {
     }
     target.artifacts = [...written];
 }
-export function createRebuildActiveStore(options) {
-    return {
-        prepare: (target) => prepareLifecycleActiveSnapshot({
-            ...(target.identity.sourceId ? {
-                sourceId: target.identity.sourceId,
-                sourceIdentity: target.identity.sourceIdentity,
-            } : {}),
-            plugin: target.lifecycleSource,
-            platform: target.identity.platform,
-            scope: target.identity.scope,
-            cwd: target.identity.cwd,
-            artifacts: target.artifacts,
-            loadPlugin: options.loadPlugin,
-            env: options.env,
-            lifecycleLeaseHeld: options.isLifecycleLeaseHeld?.() === true,
-        }),
-        discard: discardLifecycleActiveSnapshot,
-        promote: promoteLifecycleActiveSnapshot,
-        read: (target) => readLifecycleActiveSnapshot({
-            ...(target.identity.sourceId ? {
-                sourceId: target.identity.sourceId,
-                sourceIdentity: target.identity.sourceIdentity,
-            } : {}),
-            pluginName: target.identity.pluginName,
-            platform: target.identity.platform,
-            scope: target.identity.scope,
-            cwd: target.identity.cwd,
-            loadPlugin: options.loadPlugin,
-            env: options.env,
-        }),
-        readStable: (target) => leaseLifecycleActiveSnapshot({
-            ...(target.identity.sourceId ? {
-                sourceId: target.identity.sourceId,
-                sourceIdentity: target.identity.sourceIdentity,
-            } : {}),
-            pluginName: target.identity.pluginName,
-            platform: target.identity.platform,
-            scope: target.identity.scope,
-            cwd: target.identity.cwd,
-            loadPlugin: options.loadPlugin,
-            env: options.env,
-            lifecycleLeaseHeld: options.isLifecycleLeaseHeld?.() === true,
-        }),
-        remove: (target) => removeLifecycleActiveSnapshot({
-            ...(target.identity.sourceId ? {
-                sourceId: target.identity.sourceId,
-                sourceIdentity: target.identity.sourceIdentity,
-            } : {}),
-            pluginName: target.identity.pluginName,
-            platform: target.identity.platform,
-            scope: target.identity.scope,
-            cwd: target.identity.cwd,
-            env: options.env,
-            lifecycleLeaseHeld: options.isLifecycleLeaseHeld?.() === true,
-        }),
-        acquireOperation: (identity) => acquireLifecycleOperationLock({
-            ...(identity.sourceId ? {
-                sourceId: identity.sourceId,
-                sourceIdentity: identity.sourceIdentity,
-            } : {}),
-            pluginName: identity.pluginName,
-            platform: identity.platform,
-            scope: identity.scope,
-            cwd: identity.cwd,
-            env: options.env,
-        }),
-        releaseRead: releaseLifecycleActiveSnapshot,
-    };
-}
 function createAccumulator() {
     return {
         actions: [],
@@ -111,26 +37,14 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 const REBUILD_ACTION_FAILURE_MESSAGES = {
-    'operation.lock': '获取操作锁失败。',
     'preflight.inspect': '检查当前组件失败。',
     'stale.cleanup': '清理过期组件失败。',
     'native.write': '写入平台插件失败。',
     'artifacts.write': '写入插件文件失败。',
-    'active.prepare': '准备生命周期快照失败。',
-    'active.discard': '丢弃生命周期快照失败。',
-    'lifecycle.install': '运行安装生命周期失败。',
-    'lifecycle.upgrade': '运行升级生命周期失败。',
-    'lifecycle.uninstall': '运行卸载生命周期失败。',
-    'active.promote': '启用生命周期快照失败。',
+    preApply: '运行 preApply 失败。',
     'postcheck.inspect': '检查写入结果失败。',
-    'marketplace.commit': '提交 marketplace generation 失败。',
-    'marketplace.rollback': '回滚 marketplace generation 失败。',
     'recovery.cleanup': '清理失败写入失败。',
     'cleanup.owned': '清理 AW 组件失败。',
-    'active.read': '读取生命周期快照失败。',
-    'active.remove': '删除生命周期快照失败。',
-    'active.release': '释放生命周期快照失败。',
-    'operation.release': '释放操作锁失败。',
 };
 function rebuildActionFailureMessage(name) {
     return REBUILD_ACTION_FAILURE_MESSAGES[name];
@@ -143,22 +57,6 @@ async function emitRebuildAction(events, event) {
         // Progress diagnostics must not change the rebuild result.
     }
 }
-export async function releaseRebuildOperationLease(lock) {
-    let lastError;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-        try {
-            await lock.release();
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (!new Set(['EACCES', 'EBUSY', 'EINTR', 'EIO', 'ENOTEMPTY', 'EPERM']).has(error.code ?? '')) {
-                throw error;
-            }
-        }
-    }
-    throw lastError;
-}
 function pushUnique(target, values) {
     for (const value of values) {
         if (!target.includes(value))
@@ -179,16 +77,16 @@ function mergeCleanup(accumulator, cleanup, phase) {
 function succeeded(command, target, accumulator) {
     return { status: 'succeeded', command, target: target.identity, ...accumulator };
 }
-function failed(command, target, accumulator, phase, message) {
+function failed(command, target, accumulator, phase, message, operationDiagnostic) {
     if (!accumulator.failures.some((failure) => failure.phase === phase && failure.message === message)) {
-        accumulator.failures.unshift({ phase, message });
+        accumulator.failures.unshift({ phase, message, ...(operationDiagnostic ? { operationDiagnostic } : {}) });
     }
     return {
         status: 'failed',
         command,
         target: target.identity,
         ...accumulator,
-        error: { phase, message },
+        error: { phase, message, ...(operationDiagnostic ? { operationDiagnostic } : {}) },
     };
 }
 async function action(accumulator, name, operation, events, failureMessage) {
@@ -259,10 +157,10 @@ function validateDesiredTarget(target) {
         throw new Error('Desired target has an invalid namespaced source identity.');
     }
     if (target.plugin.manifest.name !== pluginName
-        || target.lifecycleSource.manifest.name !== pluginName
+        || target.preApplySource.manifest.name !== pluginName
         || target.plugin.manifest.version !== pluginVersion
-        || target.lifecycleSource.manifest.version !== pluginVersion) {
-        throw new Error('Desired target plugin name/version does not match its lifecycle source and identity.');
+        || target.preApplySource.manifest.version !== pluginVersion) {
+        throw new Error('Desired target plugin name/version does not match its preApply source and identity.');
     }
     if (platform !== 'codex' && platform !== 'claude') {
         throw new Error(`Desired target platform is invalid: ${String(platform)}`);
@@ -272,15 +170,26 @@ function validateDesiredTarget(target) {
     }
     const identityKeys = new Set();
     const componentPaths = new Set();
+    const desiredComponents = target.desiredOwnedComponents ?? target.ownedComponents;
+    const desiredComponentSet = new Set(desiredComponents);
+    const sharedNativeSkillKeys = new Set((target.plugin.manifest.artifacts?.targets ?? [])
+        .filter((artifactTarget) => artifactTarget.platform === 'codex'
+        && artifactTarget.target === 'codex.skill'
+        && artifactTarget.delivery?.mode === 'codex-native')
+        .map((artifactTarget) => artifactTarget.skillKey));
     let nativeCount = 0;
     for (const component of target.ownedComponents) {
         validateOwnerIdentity(component.identity);
+        const crossScopeLegacyNativeSkill = platform === 'codex'
+            && component.kind === 'skill-directory'
+            && !desiredComponentSet.has(component)
+            && sharedNativeSkillKeys.has(component.identity.artifactKey)
+            && component.identity.scope !== scope;
         if (component.identity.plugin !== pluginName
             || component.identity.sourceId !== sourceId
-            || component.identity.sourceIdentity !== sourceIdentity
             || component.identity.pluginId !== pluginId
             || component.identity.platform !== platform
-            || component.identity.scope !== scope) {
+            || (component.identity.scope !== scope && !crossScopeLegacyNativeSkill)) {
             throw new Error('Owned component identity does not match the desired target.');
         }
         const identityKey = [
@@ -308,7 +217,9 @@ function validateDesiredTarget(target) {
             }
         }
     }
-    const desiredComponents = target.desiredOwnedComponents ?? target.ownedComponents;
+    if (target.forceExclusiveCleanup && target.ownedComponents.some((component) => component.kind !== 'skill-directory' && component.kind !== 'owned-text-file')) {
+        throw new Error('Force cleanup only supports exclusive skill directories and owned text files.');
+    }
     nativeCount = desiredComponents.filter((component) => component.kind === 'native-plugin').length;
     if (target.requiresNative ? nativeCount !== 1 : nativeCount !== 0) {
         throw new Error(target.requiresNative
@@ -334,7 +245,7 @@ function collisionMessage(inspection) {
     if (inspection.errors.length > 0) {
         return inspection.errors.map((error) => `${error.label}: ${error.message}`).join('; ');
     }
-    const collision = inspection.components.find((component) => (component.state === 'partial' || component.state === 'error'));
+    const collision = inspection.components.find((component) => (component.state === 'partial' || component.state === 'foreign' || component.state === 'error'));
     if (collision) {
         return collision.diagnostic ?? 'Owned component preflight failed.';
     }
@@ -353,7 +264,7 @@ function isUninstallLiveOwnershipComponent(component) {
 }
 function recordInspectionResiduals(accumulator, inspection) {
     pushUnique(accumulator.residual, inspection.components
-        .filter((component) => component.state === 'partial' || component.state === 'error')
+        .filter((component) => (component.state === 'partial' || component.state === 'foreign' || component.state === 'error'))
         .map((component) => ownedComponentLabel(component.component)));
 }
 function postcheckMessage(accumulator, inspection) {
@@ -371,6 +282,11 @@ function postcheckMessage(accumulator, inspection) {
         })));
         return inspection.errors.map((error) => `${error.label}: ${error.message}`).join('; ');
     }
+    if (invalid.some((component) => component.state === 'partial'
+        && component.component.kind === 'native-plugin'
+        && component.component.identity.platform === 'codex')) {
+        return 'codexActivationPostcheckFailed: Codex scope activation was not observed as enabled.';
+    }
     const diagnostics = invalid
         .map((component) => component.diagnostic)
         .filter((diagnostic) => diagnostic !== undefined);
@@ -378,17 +294,20 @@ function postcheckMessage(accumulator, inspection) {
         return diagnostics.join('; ');
     return `Post-install ownership inspection failed for ${invalid.length} component(s).`;
 }
-async function cleanupOwned(target, driver, components = target.ownedComponents) {
-    return withOwnershipLease(target, driver, () => cleanupOwnedComponents({
+async function cleanupOwned(target, driver, components = target.ownedComponents, hooks = {}) {
+    return cleanupOwnedComponents({
         components,
+        executor: driver.ownership,
         nativeProbe: driver.probeNative,
         nativeRemove: driver.removeNative,
-    }));
+        forceExclusive: target.forceExclusiveCleanup,
+        ...hooks,
+    });
 }
-async function cleanupTarget(target, driver, store, accumulator, ownedAction, events) {
+async function cleanupTarget(target, driver, accumulator, ownedAction, events, components = target.ownedComponents, hooks = {}) {
     accumulator.cleanupAttempted = true;
     try {
-        const cleanup = await action(accumulator, ownedAction, () => cleanupOwned(target, driver), events, (value) => value.failures[0]?.message
+        const cleanup = await action(accumulator, ownedAction, () => cleanupOwned(target, driver, components, hooks), events, (value) => value.failures[0]?.message
             ?? (value.residual.length > 0
                 ? `Ownership cleanup left residual components: ${value.residual.join(', ')}`
                 : value.quarantined.length > 0
@@ -412,41 +331,64 @@ async function cleanupTarget(target, driver, store, accumulator, ownedAction, ev
         accumulator.failures.push({ phase: ownedAction, message });
         return { phase: ownedAction, message };
     }
-    try {
-        await action(accumulator, 'active.remove', () => store.remove(target), events);
-    }
-    catch (error) {
-        const message = errorMessage(error);
-        accumulator.failures.push({ phase: 'active.remove', message });
-        return { phase: 'active.remove', message };
-    }
     return null;
 }
+export async function executeRebuildComponentCleanup(options) {
+    const accumulator = createAccumulator();
+    accumulator.actions.push(...(options.actions ?? []));
+    const cleanupError = await cleanupTarget(options.target, options.driver, accumulator, 'cleanup.owned', {
+        command: options.command,
+        target: options.target.identity,
+        emit: options.onActionEvent,
+        now: options.now ?? Date.now,
+    }, options.components, {
+        ...(options.beforeMutation ? { beforeMutation: options.beforeMutation } : {}),
+        ...(options.afterQuarantine ? { afterQuarantine: options.afterQuarantine } : {}),
+    });
+    return cleanupError
+        ? failed(options.command, options.target, accumulator, cleanupError.phase, cleanupError.message)
+        : succeeded(options.command, options.target, accumulator);
+}
 async function materializeTarget(options) {
-    const { command, lifecycleEvent, target, driver, store, accumulator, events } = options;
-    let inspection;
-    try {
-        inspection = await action(accumulator, 'preflight.inspect', () => withOwnershipLease(target, driver, async () => {
-            await driver.preflightMaterialize?.(target);
-            return inspectOwnedComponents({
-                components: target.ownedComponents,
-                nativeProbe: driver.probeNative,
-            });
-        }), events, collisionMessage);
-    }
-    catch (error) {
-        return failed(command, target, accumulator, 'preflight.inspect', errorMessage(error));
+    const { command, target, driver, accumulator, events } = options;
+    let inspection = options.inspection;
+    if (!inspection) {
+        try {
+            inspection = await action(accumulator, 'preflight.inspect', async () => {
+                await driver.preflightMaterialize?.(target);
+                return inspectOwnedComponents({
+                    components: target.ownedComponents,
+                    executor: driver.ownership,
+                    nativeProbe: driver.probeNative,
+                });
+            }, events, collisionMessage);
+        }
+        catch (error) {
+            return failed(command, target, accumulator, 'preflight.inspect', errorMessage(error), readSafeOperationError(error));
+        }
     }
     const collision = collisionMessage(inspection);
     if (collision) {
         recordInspectionResiduals(accumulator, inspection);
         return failed(command, target, accumulator, 'preflight.inspect', collision);
     }
+    if (!options.preApplyCompleted && target.preApplySource.manifest.scripts?.preApply) {
+        try {
+            await action(accumulator, 'preApply', () => driver.runPreApply({
+                target,
+                plugin: target.preApplySource,
+            }), events);
+        }
+        catch (error) {
+            return failed(command, target, accumulator, 'preApply', errorMessage(error), readSafeOperationError(error));
+        }
+    }
     const desiredComponents = new Set(target.desiredOwnedComponents ?? target.ownedComponents);
     const optionalComponents = new Set(target.optionalOwnedComponents ?? []);
     const staleComponents = target.ownedComponents.filter((component) => !desiredComponents.has(component) && !optionalComponents.has(component));
     const staleInspection = inspection.components.filter((entry) => staleComponents.includes(entry.component));
-    if (staleInspection.some((component) => component.state === 'present')) {
+    if (!options.skipStaleCleanup
+        && staleInspection.some((component) => component.state === 'present')) {
         accumulator.cleanupAttempted = true;
         let stale;
         try {
@@ -456,7 +398,7 @@ async function materializeTarget(options) {
                     : undefined));
         }
         catch (error) {
-            return failed(command, target, accumulator, 'stale.cleanup', errorMessage(error));
+            return failed(command, target, accumulator, 'stale.cleanup', errorMessage(error), readSafeOperationError(error));
         }
         mergeCleanup(accumulator, stale, 'stale.cleanup');
         if (stale.failures.length > 0 || stale.residual.length > 0) {
@@ -466,9 +408,8 @@ async function materializeTarget(options) {
         }
     }
     let failurePhase = 'native.write';
-    let prepared;
     try {
-        if (target.requiresNative) {
+        if (target.writeNativeRequired ?? target.requiresNative) {
             failurePhase = 'native.write';
             await action(accumulator, failurePhase, () => driver.writeNative(target), events);
         }
@@ -477,69 +418,43 @@ async function materializeTarget(options) {
             const writtenArtifacts = await driver.writeArtifacts(target);
             bindWrittenArtifacts(target, writtenArtifacts);
         }, events);
-        failurePhase = 'active.prepare';
-        prepared = await action(accumulator, failurePhase, () => store.prepare(target), events);
-        failurePhase = `lifecycle.${lifecycleEvent}`;
-        await action(accumulator, failurePhase, () => driver.runLifecycle({
-            event: lifecycleEvent,
-            target,
-            plugin: target.lifecycleSource,
-            artifacts: target.artifacts,
-        }), events);
-        failurePhase = 'active.promote';
-        await action(accumulator, failurePhase, () => store.promote(prepared), events);
-        failurePhase = 'postcheck.inspect';
-        await action(accumulator, failurePhase, async () => {
+        const postcheck = () => action(accumulator, 'postcheck.inspect', async () => {
             const optional = new Set(target.optionalOwnedComponents ?? []);
-            const postcheck = await withOwnershipLease(target, driver, () => inspectOwnedComponents({
+            const postcheck = await inspectOwnedComponents({
                 components: (target.desiredOwnedComponents ?? target.ownedComponents)
                     .filter((component) => !optional.has(component)),
                 nativeProbe: driver.probeNativeHealth ?? driver.probeNative,
+                executor: driver.ownership,
                 verifyHealth: true,
-            }));
+            });
             const postcheckFailure = postcheckMessage(accumulator, postcheck);
             if (postcheckFailure)
                 throw new Error(postcheckFailure);
         }, events);
-        if (driver.commitMaterialize) {
-            failurePhase = 'marketplace.commit';
-            await action(accumulator, failurePhase, () => driver.commitMaterialize(target), events);
+        failurePhase = 'postcheck.inspect';
+        if (driver.deferPostcheck?.(target, postcheck) !== true) {
+            await postcheck();
         }
         return succeeded(command, target, accumulator);
     }
     catch (error) {
         const primary = errorMessage(error);
-        if (error.durableMaterializeCommit === true) {
-            return failed(command, target, accumulator, failurePhase, primary);
+        if (error.nativeMarketplaceGroupFailure === true) {
+            return failed(command, target, accumulator, failurePhase, primary, readSafeOperationError(error));
         }
-        if (prepared) {
-            try {
-                await action(accumulator, 'active.discard', () => store.discard(prepared), events);
-            }
-            catch (discardError) {
-                accumulator.failures.push({
-                    phase: 'active.discard',
-                    message: errorMessage(discardError),
-                });
-            }
+        if (target.identity.platform === 'codex') {
+            const recoveryComponents = target.ownedComponents.filter((component) => component.kind === 'skill-directory' || component.kind === 'owned-text-file');
+            await cleanupTarget(target, driver, accumulator, 'recovery.cleanup', events, driver.selectRecoveryCleanupComponents?.(target, recoveryComponents)
+                ?? recoveryComponents);
         }
-        await cleanupTarget(target, driver, store, accumulator, 'recovery.cleanup', events);
-        if (driver.rollbackMaterialize) {
-            try {
-                await action(accumulator, 'marketplace.rollback', () => driver.rollbackMaterialize(target), events);
-            }
-            catch (rollbackError) {
-                accumulator.failures.push({
-                    phase: 'marketplace.rollback',
-                    message: errorMessage(rollbackError),
-                });
-            }
+        else {
+            await cleanupTarget(target, driver, accumulator, 'recovery.cleanup', events);
         }
-        return failed(command, target, accumulator, failurePhase, primary);
+        return failed(command, target, accumulator, failurePhase, primary, readSafeOperationError(error));
     }
 }
 async function executeCleanup(options) {
-    const cleanupError = await cleanupTarget(options.target, options.driver, options.store, options.accumulator, 'cleanup.owned', options.events);
+    const cleanupError = await cleanupTarget(options.target, options.driver, options.accumulator, 'cleanup.owned', options.events);
     if (cleanupError) {
         return failed(options.command, options.target, options.accumulator, cleanupError.phase, cleanupError.message);
     }
@@ -554,13 +469,14 @@ async function executeCleanup(options) {
     return succeeded(options.command, options.target, options.accumulator);
 }
 async function executeUninstall(options) {
-    const { target, driver, store, accumulator, events } = options;
+    const { target, driver, accumulator, events } = options;
     let inspection;
     try {
-        inspection = await action(accumulator, 'preflight.inspect', () => withOwnershipLease(target, driver, () => inspectOwnedComponents({
+        inspection = await action(accumulator, 'preflight.inspect', () => inspectOwnedComponents({
             components: target.ownedComponents,
+            executor: driver.ownership,
             nativeProbe: driver.probeNative,
-        })), events, collisionMessage);
+        }), events, collisionMessage);
     }
     catch (error) {
         return failed('uninstall', target, accumulator, 'preflight.inspect', errorMessage(error));
@@ -570,80 +486,11 @@ async function executeUninstall(options) {
         recordInspectionResiduals(accumulator, inspection);
         return failed('uninstall', target, accumulator, 'preflight.inspect', preflightCollision);
     }
-    let snapshot;
-    const stableRead = store.readStable !== undefined;
-    try {
-        snapshot = await action(accumulator, 'active.read', () => (store.readStable ?? store.read)(target), events);
-    }
-    catch (error) {
-        const message = `Active lifecycle snapshot is corrupt. Run cleanup to remove live outputs without lifecycle: ${errorMessage(error)}`;
-        return failed('uninstall', target, accumulator, 'active.read', message);
-    }
-    if (!snapshot) {
-        const live = inspection.components.filter((component) => component.state !== 'absent'
-            && isUninstallLiveOwnershipComponent(component.component));
-        if (live.length === 0)
-            return succeeded('uninstall', target, accumulator);
-        if (!target.plugin.manifest.scripts?.lifecycle?.uninstall) {
-            const cleanupError = await cleanupTarget(target, driver, store, accumulator, 'cleanup.owned', events);
-            if (cleanupError) {
-                return failed('uninstall', target, accumulator, cleanupError.phase, cleanupError.message);
-            }
-            if (driver.finalizeCleanup) {
-                try {
-                    await driver.finalizeCleanup(target);
-                }
-                catch (error) {
-                    return failed('uninstall', target, accumulator, 'cleanup.owned', errorMessage(error));
-                }
-            }
-            return succeeded('uninstall', target, accumulator);
-        }
-        pushUnique(accumulator.residual, live.map((component) => ownedComponentLabel(component.component)));
-        return failed('uninstall', target, accumulator, 'active.read', 'Active lifecycle snapshot is missing while live owned components exist. Run cleanup to remove them without lifecycle.');
-    }
-    const live = inspection.components.filter((component) => component.state === 'present'
+    const live = inspection.components.filter((component) => component.state !== 'absent'
         && isUninstallLiveOwnershipComponent(component.component));
-    if (live.length === 0) {
-        if (stableRead && store.releaseRead) {
-            try {
-                await action(accumulator, 'active.release', () => store.releaseRead(snapshot), events);
-            }
-            catch (error) {
-                return failed('uninstall', target, accumulator, 'active.release', errorMessage(error));
-            }
-        }
-        return failed('uninstall', target, accumulator, 'preflight.inspect', 'liveOwnershipRequired: uninstall requires at least one live owned or native component. Run cleanup to remove orphan lifecycle metadata.');
-    }
-    const historical = restoreLifecycleActiveScriptInputs(snapshot);
-    let lifecycleError;
-    try {
-        await action(accumulator, 'lifecycle.uninstall', () => driver.runLifecycle({
-            event: 'uninstall',
-            target,
-            plugin: historical.currentPlugin,
-            artifacts: historical.artifacts,
-        }), events);
-    }
-    catch (error) {
-        lifecycleError = error;
-    }
-    if (stableRead && store.releaseRead) {
-        try {
-            await action(accumulator, 'active.release', () => store.releaseRead(snapshot), events);
-        }
-        catch (error) {
-            const message = errorMessage(error);
-            accumulator.failures.push({ phase: 'active.release', message });
-            if (lifecycleError === undefined) {
-                return failed('uninstall', target, accumulator, 'active.release', message);
-            }
-        }
-    }
-    if (lifecycleError !== undefined) {
-        return failed('uninstall', target, accumulator, 'lifecycle.uninstall', errorMessage(lifecycleError));
-    }
-    const cleanupError = await cleanupTarget(target, driver, store, accumulator, 'cleanup.owned', events);
+    if (live.length === 0)
+        return succeeded('uninstall', target, accumulator);
+    const cleanupError = await cleanupTarget(target, driver, accumulator, 'cleanup.owned', events);
     if (cleanupError) {
         return failed('uninstall', target, accumulator, cleanupError.phase, cleanupError.message);
     }
@@ -659,62 +506,62 @@ async function executeUninstall(options) {
 }
 export async function executeRebuildOperation(options) {
     const accumulator = createAccumulator();
-    const store = options.activeStore;
     const events = {
         command: options.command,
         target: options.target.identity,
         emit: options.onActionEvent,
         now: options.now ?? Date.now,
     };
+    if (options.preparation) {
+        if (options.preparation.command !== options.command
+            || options.preparation.target !== options.target) {
+            return failed(options.command, options.target, accumulator, 'preflight', 'Prepared rebuild operation does not match the requested target.');
+        }
+        accumulator.actions.push(...options.preparation.actions);
+        try {
+            await options.driver.preflightMutation?.(options.target);
+        }
+        catch (error) {
+            return failed(options.command, options.target, accumulator, 'preflight', errorMessage(error));
+        }
+        try {
+            return await executeRebuildOperationCore(options, accumulator, events, options.preparation);
+        }
+        catch (error) {
+            return failed(options.command, options.target, accumulator, 'preflight', errorMessage(error));
+        }
+    }
     try {
         validateDesiredTarget(options.target);
     }
     catch (error) {
         return failed(options.command, options.target, accumulator, 'preflight', errorMessage(error));
     }
-    let operationLock;
-    if (store.acquireOperation) {
-        try {
-            operationLock = await action(accumulator, 'operation.lock', () => store.acquireOperation(options.target.identity), events);
-        }
-        catch (error) {
-            return failed(options.command, options.target, accumulator, 'operation.lock', errorMessage(error));
-        }
-    }
-    let result;
     try {
-        const execute = () => executeRebuildOperationLocked(options, accumulator, store, events);
-        result = options.target.identity.sourceId !== undefined
-            ? await (options.driver.withMaterializeLease?.(options.target, execute) ?? execute())
-            : await execute();
+        await options.driver.preflightMutation?.(options.target);
     }
     catch (error) {
-        result = failed(options.command, options.target, accumulator, 'preflight', errorMessage(error));
+        return failed(options.command, options.target, accumulator, 'preflight', errorMessage(error));
     }
-    if (operationLock) {
-        try {
-            await action(accumulator, 'operation.release', () => releaseRebuildOperationLease(operationLock), events);
-        }
-        catch (error) {
-            const message = errorMessage(error);
-            accumulator.failures.push({ phase: 'operation.release', message });
-            if (result.status === 'succeeded') {
-                return failed(options.command, options.target, accumulator, 'operation.release', message);
-            }
-        }
+    try {
+        return await executeRebuildOperationCore(options, accumulator, events);
+    }
+    catch (error) {
+        return failed(options.command, options.target, accumulator, 'preflight', errorMessage(error));
     }
-    return result;
 }
-async function executeRebuildOperationLocked(options, accumulator, store, events) {
-    if (options.command === 'install' || options.command === 'upgrade') {
+async function executeRebuildOperationCore(options, accumulator, events, preparation) {
+    if (options.command === 'install') {
         return materializeTarget({
             command: options.command,
-            lifecycleEvent: options.command,
             target: options.target,
             driver: options.driver,
-            store,
             accumulator,
             events,
+            ...(preparation ? {
+                inspection: preparation.inspection,
+                preApplyCompleted: true,
+            } : {}),
         });
     }
     if (options.command === 'cleanup') {
@@ -722,7 +569,6 @@ async function executeRebuildOperationLocked(options, accumulator, store, events
             command: 'cleanup',
             target: options.target,
             driver: options.driver,
-            store,
             accumulator,
             events,
         });
@@ -731,34 +577,46 @@ async function executeRebuildOperationLocked(options, accumulator, store, events
         return executeUninstall({
             target: options.target,
             driver: options.driver,
-            store,
             accumulator,
             events,
         });
     }
-    let inspection;
-    try {
-        inspection = await action(accumulator, 'preflight.inspect', () => withOwnershipLease(options.target, options.driver, async () => {
-            await options.driver.preflightMaterialize?.(options.target);
-            return inspectOwnedComponents({
-                components: options.target.ownedComponents,
-                nativeProbe: options.driver.probeNative,
-            });
-        }), events, collisionMessage);
-    }
-    catch (error) {
-        return failed('reinstall', options.target, accumulator, 'preflight.inspect', errorMessage(error));
-    }
-    const collision = collisionMessage(inspection);
-    if (collision) {
-        recordInspectionResiduals(accumulator, inspection);
-        return failed('reinstall', options.target, accumulator, 'preflight.inspect', collision);
+    let inspection = preparation?.inspection;
+    if (!inspection) {
+        try {
+            inspection = await action(accumulator, 'preflight.inspect', async () => {
+                await options.driver.preflightMaterialize?.(options.target);
+                return inspectOwnedComponents({
+                    components: options.target.ownedComponents,
+                    executor: options.driver.ownership,
+                    nativeProbe: options.driver.probeNative,
+                });
+            }, events, collisionMessage);
+        }
+        catch (error) {
+            return failed('reinstall', options.target, accumulator, 'preflight.inspect', errorMessage(error));
+        }
+        const collision = collisionMessage(inspection);
+        if (collision) {
+            recordInspectionResiduals(accumulator, inspection);
+            return failed('reinstall', options.target, accumulator, 'preflight.inspect', collision);
+        }
+        if (options.target.preApplySource.manifest.scripts?.preApply) {
+            try {
+                await action(accumulator, 'preApply', () => options.driver.runPreApply({
+                    target: options.target,
+                    plugin: options.target.preApplySource,
+                }), events);
+            }
+            catch (error) {
+                return failed('reinstall', options.target, accumulator, 'preApply', errorMessage(error), readSafeOperationError(error));
+            }
+        }
     }
     const cleanupResult = await executeCleanup({
         command: 'reinstall',
         target: options.target,
         driver: options.driver,
-        store,
         accumulator,
         events,
     });
@@ -766,14 +624,83 @@ async function executeRebuildOperationLocked(options, accumulator, store, events
         return cleanupResult;
     return materializeTarget({
         command: 'reinstall',
-        lifecycleEvent: 'install',
         target: options.target,
         driver: options.driver,
-        store,
         accumulator,
         events,
+        inspection,
+        preApplyCompleted: true,
+        skipStaleCleanup: true,
     });
 }
+export async function prepareRebuildOperation(options) {
+    const accumulator = createAccumulator();
+    const events = {
+        command: options.command,
+        target: options.target.identity,
+        emit: options.onActionEvent,
+        now: options.now ?? Date.now,
+    };
+    try {
+        validateDesiredTarget(options.target);
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            result: failed(options.command, options.target, accumulator, 'preflight', errorMessage(error)),
+        };
+    }
+    let inspection;
+    try {
+        inspection = await action(accumulator, 'preflight.inspect', async () => {
+            await options.driver.preflightMaterialize?.(options.target);
+            return inspectOwnedComponents({
+                components: options.deferNativeInspection
+                    ? options.target.ownedComponents.filter((component) => component.kind !== 'native-plugin')
+                    : options.target.ownedComponents,
+                executor: options.driver.ownership,
+                nativeProbe: options.driver.probeNative,
+            });
+        }, events, collisionMessage);
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            result: failed(options.command, options.target, accumulator, 'preflight.inspect', errorMessage(error)),
+        };
+    }
+    const collision = collisionMessage(inspection);
+    if (collision) {
+        recordInspectionResiduals(accumulator, inspection);
+        return {
+            status: 'failed',
+            result: failed(options.command, options.target, accumulator, 'preflight.inspect', collision),
+        };
+    }
+    if (!options.skipPreApply && options.target.preApplySource.manifest.scripts?.preApply) {
+        try {
+            await action(accumulator, 'preApply', () => options.driver.runPreApply({
+                target: options.target,
+                plugin: options.target.preApplySource,
+            }), events);
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                result: failed(options.command, options.target, accumulator, 'preApply', errorMessage(error), readSafeOperationError(error)),
+            };
+        }
+    }
+    return {
+        status: 'ready',
+        preparation: {
+            command: options.command,
+            target: options.target,
+            inspection,
+            actions: accumulator.actions,
+        },
+    };
+}
 export async function executeRebuildTargets(options) {
     const results = [];
     for (const target of options.targets) {
@@ -781,11 +708,24 @@ export async function executeRebuildTargets(options) {
             command: options.command,
             target,
             driver: options.driver,
-            activeStore: options.activeStore,
             ...(options.onActionEvent ? { onActionEvent: options.onActionEvent } : {}),
             ...(options.now ? { now: options.now } : {}),
         }));
     }
+    const postcheckFailures = await options.driver.completePostchecks?.() ?? [];
+    for (const failure of postcheckFailures) {
+        const index = results.findIndex((result) => result.target === failure.target.identity);
+        if (index === -1 || results[index].status === 'failed')
+            continue;
+        const result = results[index];
+        const message = errorMessage(failure.error);
+        result.failures.unshift({ phase: 'postcheck.inspect', message });
+        results[index] = {
+            ...result,
+            status: 'failed',
+            error: { phase: 'postcheck.inspect', message },
+        };
+    }
     return results;
 }
 //# sourceMappingURL=rebuild-operations.js.map