@lesliechan721/aw 0.1.0-beta.5 → 0.1.0-beta.50

package/dist/src/utils/ownership.js

@@ -2,13 +2,12 @@ import crypto from 'node:crypto';
 import { promises as nodeFs } from 'node:fs';
 import path from 'node:path';
 import fs from 'fs-extra';
+import { atomicReplaceSafeFile } from './safe-fs.js';
 export const SKILL_OWNER_MARKER = '.agent-workflows-owner.json';
 export const OWNED_TEXT_HEADER_PREFIX = '# agent-workflows-owner: ';
-export const SHARED_OWNER_TOKEN_PREFIX = 'aw-owner-v2:';
+export const SHARED_OWNER_TOKEN_PREFIX = 'aw-owner-v3:';
 export function createSharedOwnerToken(identity) {
     validateOwnerIdentity(identity);
-    if (!identity.sourceId)
-        return identity.plugin;
     return `${SHARED_OWNER_TOKEN_PREFIX}${Buffer.from(createSkillOwnerMarkerContent(identity)).toString('base64url')}`;
 }
 export function parseSharedOwnerToken(value) {
@@ -22,17 +21,13 @@ export function parseSharedOwnerToken(value) {
         throw new Error('Shared owner token is invalid.');
     }
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)
-        || parsed.schemaVersion !== 2) {
-        throw new Error('Shared owner token must contain schema 2 identity.');
+        || parsed.schemaVersion !== 3) {
+        throw new Error('Shared owner token must contain schema 3 identity.');
     }
     return parseOwnerIdentity(parsed, 'Shared owner token');
 }
 class OwnershipSymlinkError extends Error {
 }
-let atomicReplaceBeforeRenameHookForTests;
-export function setAtomicReplaceBeforeRenameHookForTests(hook) {
-    atomicReplaceBeforeRenameHookForTests = hook;
-}
 function isMissing(error) {
     const code = error.code;
     return code === 'ENOENT' || code === 'ENOTDIR';
@@ -55,15 +50,12 @@ export function validateOwnerIdentity(identity) {
     }
     assertSafeOwnershipSegment(identity.plugin, 'Owner identity.plugin');
     assertSafeOwnershipSegment(identity.artifactKey, 'Owner identity.artifactKey');
-    const sourceFields = [identity.sourceId, identity.sourceIdentity, identity.pluginId];
+    const sourceFields = [identity.sourceId, identity.pluginId];
     if (sourceFields.some((value) => value !== undefined)) {
         if (sourceFields.some((value) => typeof value !== 'string' || value.length === 0)) {
             throw new Error('Owner identity source fields must be present together.');
         }
         assertSafeOwnershipSegment(identity.sourceId, 'Owner identity.sourceId');
-        if (!/^sha256:[0-9a-f]{64}$/u.test(identity.sourceIdentity)) {
-            throw new Error('Owner identity.sourceIdentity must be a SHA-256 digest.');
-        }
         if (identity.pluginId !== `${identity.sourceId}/${identity.plugin}`) {
             throw new Error('Owner identity.pluginId must be the canonical sourceId/plugin name.');
         }
@@ -78,7 +70,6 @@ export function validateOwnerIdentity(identity) {
 function identitiesEqual(left, right) {
     return left.owner === right.owner &&
         left.sourceId === right.sourceId &&
-        left.sourceIdentity === right.sourceIdentity &&
         left.pluginId === right.pluginId &&
         left.plugin === right.plugin &&
         left.artifactKey === right.artifactKey &&
@@ -87,15 +78,11 @@ function identitiesEqual(left, right) {
 }
 function markerFromIdentity(identity) {
     validateOwnerIdentity(identity);
-    const namespaced = identity.sourceId !== undefined;
     return {
-        schemaVersion: namespaced ? 2 : 1,
+        schemaVersion: 3,
         owner: identity.owner,
-        ...(namespaced ? {
-            sourceId: identity.sourceId,
-            sourceIdentity: identity.sourceIdentity,
-            pluginId: identity.pluginId,
-        } : {}),
+        sourceId: identity.sourceId,
+        pluginId: identity.pluginId,
         plugin: identity.plugin,
         artifactKey: identity.artifactKey,
         platform: identity.platform,
@@ -111,7 +98,6 @@ function parseOwnerIdentity(value, label) {
         'schemaVersion',
         'owner',
         'sourceId',
-        'sourceIdentity',
         'pluginId',
         'plugin',
         'artifactKey',
@@ -121,21 +107,14 @@ function parseOwnerIdentity(value, label) {
     if (Object.keys(record).some((key) => !allowedKeys.has(key))) {
         throw new Error(`${label} 包含未知字段。`);
     }
-    if (record.schemaVersion !== 1 && record.schemaVersion !== 2) {
-        throw new Error(`${label}.schemaVersion 不受支持。`);
-    }
-    if (record.schemaVersion === 2 && (typeof record.sourceId !== 'string'
-        || typeof record.sourceIdentity !== 'string'
+    if (record.schemaVersion !== 3 || (typeof record.sourceId !== 'string'
         || typeof record.pluginId !== 'string')) {
-        throw new Error(`${label}.schemaVersion 必须是 1，或提供完整 schema 2 source identity。`);
+        throw new Error(`${label} must use schema 3 stable plugin identity. This beta hard cut requires a new AW_HOME, or cleanup with the old CLI first.`);
     }
     const identity = {
         owner: record.owner,
-        ...(record.schemaVersion === 2 ? {
-            sourceId: record.sourceId,
-            sourceIdentity: record.sourceIdentity,
-            pluginId: record.pluginId,
-        } : {}),
+        sourceId: record.sourceId,
+        pluginId: record.pluginId,
         plugin: record.plugin,
         artifactKey: record.artifactKey,
         platform: record.platform,
@@ -176,60 +155,15 @@ async function assertNoSymlinkInPath(allowedRoot, candidatePath) {
         }
     }
 }
-async function readDirectoryIdentity(directoryPath) {
-    const stats = await fs.lstat(directoryPath);
-    if (stats.isSymbolicLink() || !stats.isDirectory()) {
-        throw new OwnershipSymlinkError(`Ownership 稳定目录必须是真实目录：${directoryPath}`);
-    }
-    return {
-        dev: stats.dev,
-        ino: stats.ino,
-        realPath: await fs.realpath(directoryPath),
-    };
-}
-function assertStableDirectory(label, before, after) {
-    if (before.dev !== after.dev || before.ino !== after.ino || before.realPath !== after.realPath) {
-        throw new Error(`${label} identity 在 atomic rename 前发生变化。`);
-    }
-}
-function assertRealDirectoryBoundary(root, parent) {
-    const relative = path.relative(root.realPath, parent.realPath);
-    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw new Error('Ownership parent realpath 不在 allowedRoot realpath 内。');
-    }
-}
 async function atomicReplaceFile(options) {
-    await assertNoSymlinkInPath(options.allowedRoot, options.path);
-    await fs.ensureDir(path.dirname(options.path));
-    await assertNoSymlinkInPath(options.allowedRoot, options.path);
-    const rootIdentity = await readDirectoryIdentity(path.resolve(options.allowedRoot));
-    const parentIdentity = await readDirectoryIdentity(path.dirname(path.resolve(options.path)));
-    assertRealDirectoryBoundary(rootIdentity, parentIdentity);
-    const temporaryPath = path.join(path.dirname(options.path), `.${path.basename(options.path)}.owner-${process.pid}-${crypto.randomUUID()}`);
-    assertPathBoundary(options.allowedRoot, temporaryPath);
-    let handle;
-    try {
-        handle = await nodeFs.open(temporaryPath, 'wx', 0o666);
-        await handle.writeFile(options.content, 'utf8');
-        await handle.close();
-        handle = undefined;
-        await atomicReplaceBeforeRenameHookForTests?.();
-        // Threat model: this blocks pre-existing symlinks/hardlinks, traversal, and callers that use
-        // this API concurrently. Node has no portable dirfd/openat/renameat2 sequence, so this does not
-        // claim to stop a process with the same file permissions from swapping a directory after this
-        // final check and before rename; that process can already edit or delete the user's files.
-        await assertNoSymlinkInPath(options.allowedRoot, options.path);
-        const currentRootIdentity = await readDirectoryIdentity(path.resolve(options.allowedRoot));
-        const currentParentIdentity = await readDirectoryIdentity(path.dirname(path.resolve(options.path)));
-        assertRealDirectoryBoundary(currentRootIdentity, currentParentIdentity);
-        assertStableDirectory('allowedRoot', rootIdentity, currentRootIdentity);
-        assertStableDirectory('parent', parentIdentity, currentParentIdentity);
-        await nodeFs.rename(temporaryPath, options.path);
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-        await nodeFs.rm(temporaryPath, { force: true }).catch(() => undefined);
-    }
+    await atomicReplaceSafeFile({
+        filePath: options.path,
+        allowedRoot: options.allowedRoot,
+        content: options.content,
+        mode: 0o666,
+        label: 'Ownership path',
+        temporaryTag: 'owner',
+    });
 }
 export async function assertOwnedSkillPath(options) {
     validateOwnerIdentity(options.identity);
@@ -296,14 +230,6 @@ export async function readSkillOwnerMarker(options) {
     if (marker.artifactKey !== path.basename(options.skillRoot)) {
         throw new Error('Skill owner marker artifactKey 与目录名不一致。');
     }
-    if (options.expectedIdentity?.sourceId !== undefined && marker.schemaVersion === 1) {
-        throw new Error('legacyStateUnsupported: schema 1 owner marker is not supported.');
-    }
-    if (options.expectedIdentity?.sourceId !== undefined
-        && marker.sourceId === options.expectedIdentity.sourceId
-        && marker.sourceIdentity !== options.expectedIdentity.sourceIdentity) {
-        throw new Error('sourceChanged: owner source identity does not match the configured source.');
-    }
     if (options.expectedIdentity && !identitiesEqual(marker, options.expectedIdentity)) {
         throw new Error('Skill owner marker identity 与目标 identity 不匹配。');
     }
@@ -348,14 +274,6 @@ export function parseOwnedTextHeader(content, expectedIdentity) {
         throw new Error('Owner header 不是有效 JSON。');
     }
     const identity = parseOwnerIdentity(parsed, 'Owner header');
-    if (expectedIdentity?.sourceId !== undefined && identity.sourceId === undefined) {
-        throw new Error('legacyStateUnsupported: schema 1 owner header is not supported.');
-    }
-    if (expectedIdentity?.sourceId !== undefined
-        && identity.sourceId === expectedIdentity.sourceId
-        && identity.sourceIdentity !== expectedIdentity.sourceIdentity) {
-        throw new Error('sourceChanged: owner source identity does not match the configured source.');
-    }
     if (expectedIdentity && !identitiesEqual(identity, expectedIdentity)) {
         throw new Error('Owner header identity 与目标 identity 不匹配。');
     }
@@ -373,13 +291,13 @@ export async function writeOwnedTextFile(options) {
         content: renderOwnedTextFile(options.content, options.identity),
     });
 }
-async function inspectPathAt(component, actualPath, canonicalPath) {
+async function inspectPathAt(component, actualPath, canonicalPath, executor) {
     try {
         await assertNoSymlinkInPath(component.allowedRoot, actualPath);
     }
     catch (error) {
         if (error instanceof OwnershipSymlinkError)
-            return 'foreign';
+            return foreignProbe(component, 'typeMismatch');
         throw error;
     }
     const stats = await fs.lstat(actualPath).catch((error) => {
@@ -388,17 +306,17 @@ async function inspectPathAt(component, actualPath, canonicalPath) {
         throw error;
     });
     if (!stats)
-        return 'absent';
+        return { state: 'absent' };
     if (component.kind === 'skill-directory') {
         if (!stats.isDirectory())
-            return 'foreign';
+            return foreignProbe(component, 'typeMismatch');
         const markerPath = path.join(actualPath, SKILL_OWNER_MARKER);
         try {
             await assertNoSymlinkInPath(component.allowedRoot, markerPath);
         }
         catch (error) {
             if (error instanceof OwnershipSymlinkError)
-                return 'foreign';
+                return foreignProbe(component, 'typeMismatch');
             throw error;
         }
         let marker;
@@ -408,35 +326,143 @@ async function inspectPathAt(component, actualPath, canonicalPath) {
         catch (error) {
             if (error.code)
                 throw error;
-            return 'foreign';
+            return foreignProbe(component, 'unownedContent');
         }
         if (!marker) {
-            return await component.unownedIsPristine?.(actualPath) ? 'absent' : 'foreign';
+            const pristine = component.pristineTree && executor?.skillDirectoryMatchesPristineTree
+                ? await executor.skillDirectoryMatchesPristineTree({
+                    actualPath,
+                    files: component.pristineTree,
+                })
+                : false;
+            return pristine
+                ? { state: 'absent' }
+                : foreignProbe(component, 'unownedContent');
+        }
+        if (!identitiesEqual(marker, component.identity)) {
+            return foreignProbe(component, 'ownerMismatch', publicOwner(marker));
         }
-        if (!identitiesEqual(marker, component.identity))
-            return 'foreign';
-        if (canonicalPath && path.basename(actualPath) !== component.identity.artifactKey)
-            return 'foreign';
-        return 'present';
+        if (canonicalPath && path.basename(actualPath) !== component.identity.artifactKey) {
+            return foreignProbe(component, 'ownerMismatch', publicOwner(marker));
+        }
+        return { state: 'present' };
     }
     if (!stats.isFile())
-        return 'foreign';
+        return foreignProbe(component, 'typeMismatch');
     let raw;
     try {
         raw = await fs.readFile(actualPath, 'utf8');
     }
     catch (error) {
         if (isMissing(error))
-            return 'absent';
+            return { state: 'absent' };
+        throw error;
+    }
+    try {
+        const parsed = parseOwnedTextHeader(raw);
+        if (!parsed)
+            return foreignProbe(component, 'unownedContent');
+        return identitiesEqual(parsed.identity, component.identity)
+            ? { state: 'present' }
+            : foreignProbe(component, 'ownerMismatch', publicOwner(parsed.identity));
+    }
+    catch {
+        return foreignProbe(component, 'unownedContent');
+    }
+}
+function publicOwner(identity) {
+    return identity.pluginId ?? identity.plugin;
+}
+function forceArtifactBasenameMatches(component) {
+    const basename = path.basename(component.path);
+    if (component.kind === 'skill-directory')
+        return basename === component.identity.artifactKey;
+    const stem = basename.replace(/\.[^.]+$/u, '');
+    const slug = (value) => value.trim().toLowerCase()
+        .replace(/[^a-z0-9]+/gu, '-')
+        .replace(/^-+|-+$/gu, '');
+    return stem === component.identity.artifactKey
+        || stem === `aw-${slug(component.identity.plugin)}-${slug(component.identity.artifactKey)}`;
+}
+async function inspectForceExclusivePathAt(component, actualPath, canonicalPath) {
+    validateOwnerIdentity(component.identity);
+    if (canonicalPath && !forceArtifactBasenameMatches(component)) {
+        return foreignProbe(component, 'ownerMismatch');
+    }
+    try {
+        await assertNoSymlinkInPath(component.allowedRoot, actualPath);
+    }
+    catch (error) {
+        if (error instanceof OwnershipSymlinkError)
+            return foreignProbe(component, 'typeMismatch');
+        throw error;
+    }
+    const stats = await fs.lstat(actualPath).catch((error) => {
+        if (isMissing(error))
+            return null;
         throw error;
+    });
+    if (!stats)
+        return { state: 'absent' };
+    if (component.kind === 'skill-directory') {
+        if (!stats.isDirectory())
+            return foreignProbe(component, 'typeMismatch');
+        const markerPath = path.join(actualPath, SKILL_OWNER_MARKER);
+        try {
+            await assertNoSymlinkInPath(component.allowedRoot, markerPath);
+        }
+        catch (error) {
+            if (error instanceof OwnershipSymlinkError)
+                return foreignProbe(component, 'typeMismatch');
+            throw error;
+        }
+        try {
+            const marker = await readMarkerAt(markerPath);
+            if (!marker)
+                return { state: 'present' };
+            return identitiesEqual(marker, component.identity)
+                ? { state: 'present' }
+                : foreignProbe(component, 'ownerMismatch', publicOwner(marker));
+        }
+        catch (error) {
+            if (error.code)
+                throw error;
+            return { state: 'present' };
+        }
     }
+    if (!stats.isFile())
+        return foreignProbe(component, 'typeMismatch');
+    const raw = await fs.readFile(actualPath, 'utf8').catch((error) => {
+        if (isMissing(error))
+            return null;
+        throw error;
+    });
+    if (raw === null)
+        return { state: 'absent' };
     try {
-        return parseOwnedTextHeader(raw, component.identity) ? 'present' : 'foreign';
+        const parsed = parseOwnedTextHeader(raw);
+        if (!parsed)
+            return { state: 'present' };
+        return identitiesEqual(parsed.identity, component.identity)
+            ? { state: 'present' }
+            : foreignProbe(component, 'ownerMismatch', publicOwner(parsed.identity));
     }
     catch {
-        return 'foreign';
+        return { state: 'present' };
     }
 }
+function foreignProbe(component, reason, actualOwner) {
+    return {
+        state: 'foreign',
+        collision: {
+            reason,
+            artifactKind: component.kind,
+            artifactKey: component.identity.artifactKey,
+            expectedOwner: publicOwner(component.identity),
+            ...(actualOwner ? { actualOwner } : {}),
+        },
+    };
+}
 function componentLabel(component) {
     if ('path' in component)
         return component.path;
@@ -453,17 +479,21 @@ function validateNativePlugin(component) {
         throw new Error(`Native plugin identity 必须使用 ${prefix} marketplace namespace。`);
     }
 }
-async function inspectComponent(component, nativeProbe) {
+async function inspectComponent(component, nativeProbe, executor) {
     validateOwnerIdentity(component.identity);
     if ('path' in component)
-        return inspectPathAt(component, component.path, true);
+        return inspectPathAt(component, component.path, true, executor);
     if (component.kind === 'native-plugin') {
         validateNativePlugin(component);
         if (!nativeProbe)
             throw new Error('Native ownership inspection 缺少 nativeProbe。');
-        return nativeProbe(component);
+        const state = await nativeProbe(component);
+        return state === 'foreign' ? foreignProbe(component, 'ownerMismatch') : { state };
     }
-    return component.inspect();
+    if (!executor)
+        throw new Error('Shared ownership inspection 缺少 executor。');
+    const state = await executor.inspectShared(component);
+    return state === 'foreign' ? foreignProbe(component, 'ownerMismatch') : { state };
 }
 export async function inspectOwnedComponents(options) {
     const components = [];
@@ -471,14 +501,20 @@ export async function inspectOwnedComponents(options) {
     for (const component of options.components) {
         const label = componentLabel(component);
         try {
-            let probe = await inspectComponent(component, options.nativeProbe);
+            const result = await (options.forceExclusive && 'path' in component
+                ? inspectForceExclusivePathAt(component, component.path, true)
+                : inspectComponent(component, options.nativeProbe, options.executor));
+            let probe = result.state;
             let healthDiagnostic;
             if (options.verifyHealth
                 && probe === 'present'
                 && component.kind === 'skill-directory'
-                && component.validateHealth) {
+                && component.validateHealth === true) {
                 try {
-                    await component.validateHealth();
+                    if (!options.executor?.validateSkillDirectory) {
+                        throw new Error('Skill health inspection 缺少 executor。');
+                    }
+                    await options.executor.validateSkillDirectory(component);
                 }
                 catch (error) {
                     probe = 'partial';
@@ -487,7 +523,8 @@ export async function inspectOwnedComponents(options) {
             }
             components.push({
                 component,
-                state: probe === 'foreign' ? 'partial' : probe,
+                state: probe,
+                ...(result.collision ? { collision: result.collision } : {}),
                 ...(probe === 'foreign'
                     ? { diagnostic: `存在 foreign collision：${label}` }
                     : healthDiagnostic
@@ -505,7 +542,7 @@ export async function inspectOwnedComponents(options) {
     }
     const state = errors.length > 0
         ? 'error'
-        : components.length === 0 || components.every((entry) => entry.state === 'absent')
+        : components.length === 0 || components.every((entry) => (entry.state === 'absent' || entry.state === 'foreign'))
             ? 'absent'
             : components.every((entry) => entry.state === 'present')
                 ? 'present'
@@ -546,7 +583,9 @@ async function cleanupPathComponent(options) {
     }
     let verified;
     try {
-        verified = await inspectPathAt(component, quarantinePath, false);
+        verified = (await (options.forceExclusive
+            ? inspectForceExclusivePathAt(component, quarantinePath, false)
+            : inspectPathAt(component, quarantinePath, false, options.executor))).state;
     }
     catch (error) {
         result.failures.push({
@@ -589,8 +628,8 @@ async function cleanupPathComponent(options) {
         return;
     }
     try {
-        const after = await inspectComponent(component);
-        if (after === 'absent')
+        const after = await inspectComponent(component, undefined, options.executor);
+        if (after.state === 'absent')
             pushUnique(result.removed, label);
         else
             pushUnique(result.residual, label);
@@ -612,7 +651,9 @@ export async function cleanupOwnedComponents(options) {
     for (const component of options.components) {
         const label = componentLabel(component);
         try {
-            const probe = await inspectComponent(component, options.nativeProbe);
+            const probe = (await (options.forceExclusive && 'path' in component
+                ? inspectForceExclusivePathAt(component, component.path, true)
+                : inspectComponent(component, options.nativeProbe, options.executor))).state;
             probes.set(component, probe);
             if (probe === 'absent')
                 pushUnique(result.absent, label);
@@ -641,6 +682,8 @@ export async function cleanupOwnedComponents(options) {
                 component,
                 result,
                 afterQuarantine: options.afterQuarantine,
+                executor: options.executor,
+                forceExclusive: options.forceExclusive,
             });
             continue;
         }
@@ -653,7 +696,9 @@ export async function cleanupOwnedComponents(options) {
                 await options.nativeRemove(component);
             }
             else {
-                await component.remove();
+                if (!options.executor)
+                    throw new Error('Shared ownership cleanup 缺少 executor。');
+                await options.executor.removeShared(component);
             }
         }
         catch (error) {
@@ -662,8 +707,8 @@ export async function cleanupOwnedComponents(options) {
             continue;
         }
         try {
-            const after = await inspectComponent(component, options.nativeProbe);
-            if (after === 'absent')
+            const after = await inspectComponent(component, options.nativeProbe, options.executor);
+            if (after.state === 'absent')
                 pushUnique(result.removed, label);
             else
                 pushUnique(result.residual, label);
@@ -675,92 +720,4 @@ export async function cleanupOwnedComponents(options) {
     }
     return result;
 }
-export async function cleanupCorruptExclusivePluginDirectory(options) {
-    const markerPath = path.join(options.directory, SKILL_OWNER_MARKER);
-    let raw = null;
-    try {
-        const [directoryStats, markerStats] = await Promise.all([
-            nodeFs.lstat(options.directory),
-            nodeFs.lstat(markerPath),
-        ]);
-        if (!directoryStats.isDirectory() || directoryStats.isSymbolicLink()
-            || !markerStats.isFile() || markerStats.isSymbolicLink())
-            return null;
-        await assertNoSymlinkInPath(options.allowedRoot, markerPath);
-        raw = await fs.readJson(markerPath);
-    }
-    catch {
-        return null;
-    }
-    if (!raw
-        || raw.schemaVersion !== 2
-        || raw.owner !== 'agent-workflows'
-        || raw.sourceId !== options.sourceId
-        || raw.plugin !== options.pluginName
-        || raw.pluginId !== `${options.sourceId}/${options.pluginName}`
-        || raw.platform !== options.platform
-        || raw.scope !== options.scope)
-        return null;
-    assertSafeOwnershipSegment(path.basename(options.directory), 'Exclusive plugin directory');
-    const quarantinePath = path.join(path.resolve(options.allowedRoot), `.agent-workflows-quarantine-${process.pid}-${crypto.randomUUID()}`);
-    assertPathBoundary(options.allowedRoot, quarantinePath);
-    try {
-        await (options.rename ?? nodeFs.rename)(options.directory, quarantinePath);
-    }
-    catch (error) {
-        const [canonicalExists, quarantineExists] = await Promise.all([
-            fs.pathExists(options.directory),
-            fs.pathExists(quarantinePath),
-        ]);
-        if (!canonicalExists && !quarantineExists) {
-            return {
-                removed: [options.directory], absent: [], residual: [], quarantined: [], failures: [],
-            };
-        }
-        return {
-            removed: [], absent: [],
-            residual: [quarantineExists ? quarantinePath : options.directory],
-            quarantined: quarantineExists ? [quarantinePath] : [],
-            failures: [{
-                    label: options.directory,
-                    phase: 'mutation',
-                    message: errorMessage(error),
-                    ...(quarantineExists ? { quarantinePath } : {}),
-                }],
-        };
-    }
-    try {
-        await (options.remove ?? fs.remove)(quarantinePath);
-    }
-    catch (error) {
-        if (!await fs.pathExists(quarantinePath)) {
-            return {
-                removed: [options.directory], absent: [], residual: [], quarantined: [], failures: [],
-            };
-        }
-        return {
-            removed: [], absent: [], residual: [quarantinePath], quarantined: [quarantinePath],
-            failures: [{
-                    label: options.directory,
-                    phase: 'remove',
-                    message: errorMessage(error),
-                    quarantinePath,
-                }],
-        };
-    }
-    if (await fs.pathExists(quarantinePath)) {
-        return {
-            removed: [], absent: [], residual: [quarantinePath], quarantined: [quarantinePath],
-            failures: [{
-                    label: options.directory,
-                    phase: 'verify',
-                    message: 'Exclusive plugin quarantine remained after removal.',
-                    quarantinePath,
-                }],
-        };
-    }
-    return {
-        removed: [options.directory], absent: [], residual: [], quarantined: [], failures: [],
-    };
-}
 //# sourceMappingURL=ownership.js.map