@open-agent-toolkit/cli 0.2.51 → 0.2.53

package/dist/engine/compute-plan.js

@@ -4,6 +4,7 @@ import { basename, dirname, join, normalize, relative, resolve, } from 'node:pat
 import { computeContentHash, computeStringHash } from '../manifest/hash.js';
 import { findEntry } from '../manifest/manager.js';
 import { getSyncMappings } from '../providers/shared/adapter.utils.js';
+import { proveCollectionIdentity } from './collection-sync.js';
 import { OAT_DIRECTORY_SENTINEL, OAT_MARKER_PREFIX } from './markers.js';
 import { assertSafeProviderMutationPath } from './provider-path-safety.js';
 function buildUpLevels(depth) {
@@ -65,6 +66,32 @@ function resolveStrategy(adapter, config, transformCanonical) {
     }
     return 'symlink';
 }
+function resolveConfiguredStrategy(adapter, config) {
+    const providerConfig = config.providers[adapter.name];
+    if (providerConfig?.enabled === false) {
+        return null;
+    }
+    return (providerConfig?.strategy ??
+        config.defaultStrategy ??
+        adapter.defaultStrategy);
+}
+function relativeManifestPath(scopeRoot, path) {
+    return relative(scopeRoot, path).replaceAll('\\', '/');
+}
+function collectionFallbackReason(reason) {
+    if (reason === 'real-directory') {
+        return 'provider collection is a real directory; use per-entry sync';
+    }
+    return `collection identity is ${reason}; preserve the provider collection without child mutation`;
+}
+function collectionCreationIdentityMatches(collection, proof) {
+    return (collection.ownership === 'oat-created' &&
+        collection.createdLink !== undefined &&
+        proof.status === 'exact-link' &&
+        collection.createdLink.device === proof.providerLink.device &&
+        collection.createdLink.inode === proof.providerLink.inode &&
+        collection.createdLink.linkText === proof.linkText);
+}
 async function pathExists(path) {
     try {
         await access(path);
@@ -98,6 +125,22 @@ function createRetirementEntry(manifestEntry, scopeRoot, operation, reason) {
         reason,
     };
 }
+function createCollectionDetachmentEntry(manifestEntry, scopeRoot) {
+    const canonicalRelative = manifestEntry.canonicalPath;
+    return {
+        canonical: {
+            name: basename(canonicalRelative),
+            type: manifestEntry.contentType,
+            canonicalPath: resolve(scopeRoot, canonicalRelative),
+            isFile: manifestEntry.isFile,
+        },
+        provider: manifestEntry.provider,
+        providerPath: resolve(scopeRoot, manifestEntry.providerPath),
+        operation: 'detach',
+        strategy: 'symlink',
+        reason: 'collection inheritance no longer includes canonical entry',
+    };
+}
 function manifestEntryInsideMapping(entry, mapping) {
     if (entry.contentType !== mapping.contentType) {
         return false;
@@ -316,13 +359,16 @@ function canonicalPathAllowed(relativeCanonicalPath, canonicalFilter) {
     }
     return canonicalFilter.has(normalize(relativeCanonicalPath));
 }
-export async function computeSyncPlan({ canonical, adapters, manifest, scope, config, scopeRoot: explicitScopeRoot, allowedCanonicalPaths, }) {
+export async function computeSyncPlan({ canonical, adapters, manifest, scope, config, scopeRoot: explicitScopeRoot, allowedCanonicalPaths, extensionOwnedCanonicalPathsByProvider, collectionAliasEligibleMappings = [], collectionAliasCreationAvailable = false, }) {
     const entries = [];
     const removals = [];
+    const collections = [];
     const scopeRoot = resolveScopeRoot(canonical, explicitScopeRoot);
     const seenCanonicalKeys = new Set();
     const activeProviderNames = new Set();
     const activeMappingsByProvider = new Map();
+    const manifestV2 = manifest;
+    const collectionAliasEligibility = new Set(collectionAliasEligibleMappings.map(({ provider, contentType }) => `${provider}::${contentType}`));
     const canonicalFilter = allowedCanonicalPaths
         ? new Set(allowedCanonicalPaths.map((canonicalPath) => normalize(canonicalPath)))
         : null;
@@ -338,11 +384,204 @@ export async function computeSyncPlan({ canonical, adapters, manifest, scope, co
             const activeMappings = activeMappingsByProvider.get(adapter.name) ?? [];
             activeMappings.push(mapping);
             activeMappingsByProvider.set(adapter.name, activeMappings);
+            const configuredStrategy = resolveConfiguredStrategy(adapter, config);
+            const collectionCandidates = canonical.filter((canonicalEntry) => {
+                if (!entryContentTypeMatches(canonicalEntry, mapping.contentType)) {
+                    return false;
+                }
+                const relativeCanonicalPath = canonicalRelativePath(canonicalEntry);
+                const extensionOwnedPaths = extensionOwnedCanonicalPathsByProvider?.[adapter.name] ?? [];
+                return (!extensionOwnedPaths.some((ownedPath) => normalize(ownedPath) === normalize(relativeCanonicalPath)) &&
+                    canonicalPathAllowed(relativeCanonicalPath, canonicalFilter) &&
+                    entryInsideMapping(canonicalEntry, mapping.canonicalDir));
+            });
+            let inheritCollection = false;
+            let deferredCollectionTransition = false;
+            const canonicalDir = scopeRoot
+                ? resolve(scopeRoot, mapping.canonicalDir)
+                : null;
+            const providerDir = scopeRoot
+                ? resolve(scopeRoot, mapping.providerDir)
+                : null;
+            const existingCollection = scopeRoot && canonicalDir && providerDir
+                ? manifest.collections.find((collection) => collection.provider === adapter.name &&
+                    collection.contentType === mapping.contentType &&
+                    collection.canonicalDir ===
+                        relativeManifestPath(scopeRoot, canonicalDir) &&
+                    collection.providerDir ===
+                        relativeManifestPath(scopeRoot, providerDir))
+                : undefined;
+            const existingInheritedEntries = existingCollection
+                ? manifestV2.entries
+                    .filter((entry) => entry.strategy === 'collection' &&
+                    entry.collectionId === existingCollection.id)
+                    .map((entry) => entry.canonicalPath)
+                    .sort()
+                : [];
+            const collectionEligible = configuredStrategy === 'auto' &&
+                mapping.contentType === 'skill' &&
+                collectionAliasEligibility.has(`${adapter.name}::${mapping.contentType}`) &&
+                adapter.defaultStrategy !== 'copy' &&
+                !mapping.transformCanonical &&
+                !mapping.providerExtension &&
+                canonicalDir !== null &&
+                providerDir !== null &&
+                collectionCandidates.length > 0;
+            if (existingCollection !== undefined &&
+                !collectionEligible &&
+                canonicalDir !== null &&
+                providerDir !== null) {
+                const proof = await proveCollectionIdentity({
+                    root: scopeRoot,
+                    canonicalDir,
+                    providerDir,
+                });
+                const safelyClear = proof.status === 'absent' ||
+                    collectionCreationIdentityMatches(existingCollection, proof);
+                if (safelyClear) {
+                    collections.push({
+                        provider: adapter.name,
+                        scope,
+                        contentType: mapping.contentType,
+                        canonicalDir,
+                        providerDir,
+                        action: 'detach-collection',
+                        ownership: existingCollection.ownership,
+                        configuredStrategy: configuredStrategy ?? 'auto',
+                        proof,
+                        createdLink: existingCollection.createdLink,
+                        transitionToPerEntry: true,
+                        inheritedEntries: existingInheritedEntries,
+                        reason: proof.status === 'absent'
+                            ? 'collection alias is absent in this plan; revalidate absence before transitioning to explicit per-entry sync'
+                            : 'collection alias requires guarded removal before transitioning to explicit per-entry sync',
+                    });
+                    deferredCollectionTransition = true;
+                }
+                else {
+                    collections.push({
+                        provider: adapter.name,
+                        scope,
+                        contentType: mapping.contentType,
+                        canonicalDir,
+                        providerDir,
+                        action: 'reject-collection',
+                        ownership: existingCollection.ownership,
+                        configuredStrategy: configuredStrategy ?? 'auto',
+                        proof,
+                        createdLink: existingCollection.createdLink,
+                        inheritedEntries: existingInheritedEntries,
+                        reason: 'collection alias cannot be safely cleared with durable creation identity; preserve it and resolve the collection path before retrying per-entry sync',
+                    });
+                    inheritCollection = true;
+                }
+            }
+            if (collectionEligible && canonicalDir !== null && providerDir !== null) {
+                const proof = await proveCollectionIdentity({
+                    root: scopeRoot,
+                    canonicalDir,
+                    providerDir,
+                });
+                const inheritedEntries = collectionCandidates.map((entry) => relativeManifestPath(scopeRoot, entry.canonicalPath));
+                const inheritedEntriesUnchanged = existingCollection !== undefined &&
+                    existingInheritedEntries.length === inheritedEntries.length &&
+                    existingInheritedEntries.every((entry, index) => entry === [...inheritedEntries].sort()[index]);
+                if (proof.status === 'absent') {
+                    collections.push({
+                        provider: adapter.name,
+                        scope,
+                        contentType: mapping.contentType,
+                        canonicalDir,
+                        providerDir,
+                        action: collectionAliasCreationAvailable
+                            ? 'create-collection-link'
+                            : 'fallback-per-entry',
+                        ownership: collectionAliasCreationAvailable
+                            ? 'oat-created'
+                            : 'none',
+                        configuredStrategy: 'auto',
+                        proof,
+                        inheritedEntries,
+                        reason: collectionAliasCreationAvailable
+                            ? 'provider collection is absent and a guarded creation primitive is available'
+                            : 'provider collection is absent, but this runtime has no securely guarded parent-relative collection-link primitive; use safe per-entry sync',
+                    });
+                    inheritCollection = collectionAliasCreationAvailable;
+                }
+                else if (proof.status === 'exact-link') {
+                    if (!inheritedEntriesUnchanged) {
+                        collections.push({
+                            provider: adapter.name,
+                            scope,
+                            contentType: mapping.contentType,
+                            canonicalDir,
+                            providerDir,
+                            action: existingCollection === undefined
+                                ? 'adopt-collection-link'
+                                : 'inherit-collection',
+                            ownership: existingCollection?.ownership ?? 'adopted-exact',
+                            configuredStrategy: 'auto',
+                            createdLink: existingCollection?.createdLink,
+                            proof,
+                            inheritedEntries,
+                            reason: existingCollection === undefined
+                                ? 'existing collection alias exactly matches canonical target'
+                                : 'owned collection alias inheritance changed',
+                        });
+                    }
+                    inheritCollection = true;
+                }
+                else {
+                    if (existingCollection !== undefined) {
+                        collections.push({
+                            provider: adapter.name,
+                            scope,
+                            contentType: mapping.contentType,
+                            canonicalDir,
+                            providerDir,
+                            action: 'detach-collection',
+                            ownership: existingCollection.ownership,
+                            configuredStrategy: 'auto',
+                            createdLink: existingCollection.createdLink,
+                            proof,
+                            inheritedEntries: existingInheritedEntries,
+                            reason: 'owned collection alias changed or became unverifiable; preserve and detach ownership',
+                        });
+                        inheritCollection = true;
+                        continue;
+                    }
+                    const fallback = proof.reason === 'real-directory';
+                    collections.push({
+                        provider: adapter.name,
+                        scope,
+                        contentType: mapping.contentType,
+                        canonicalDir,
+                        providerDir,
+                        action: fallback ? 'fallback-per-entry' : 'reject-collection',
+                        ownership: 'none',
+                        configuredStrategy: 'auto',
+                        proof,
+                        inheritedEntries,
+                        reason: collectionFallbackReason(proof.reason),
+                    });
+                    inheritCollection = !fallback;
+                }
+            }
+            if (inheritCollection) {
+                for (const canonicalEntry of collectionCandidates) {
+                    seenCanonicalKeys.add(`${normalize(canonicalRelativePath(canonicalEntry))}::${adapter.name}`);
+                }
+                continue;
+            }
             for (const canonicalEntry of canonical) {
                 if (!entryContentTypeMatches(canonicalEntry, mapping.contentType)) {
                     continue;
                 }
                 const relativeCanonicalPath = canonicalRelativePath(canonicalEntry);
+                const extensionOwnedPaths = extensionOwnedCanonicalPathsByProvider?.[adapter.name] ?? [];
+                if (extensionOwnedPaths.some((ownedPath) => normalize(ownedPath) === normalize(relativeCanonicalPath))) {
+                    continue;
+                }
                 if (!canonicalPathAllowed(relativeCanonicalPath, canonicalFilter)) {
                     continue;
                 }
@@ -359,9 +598,21 @@ export async function computeSyncPlan({ canonical, adapters, manifest, scope, co
                 const manifestEntry = findEntry(manifest, normalize(relativeCanonicalPath), adapter.name);
                 const entryStrategy = mapping.transformCanonical
                     ? 'copy'
-                    : (manifestEntry?.strategy ?? mappingStrategy);
-                await assertSafeProviderMutationPath(entryScopeRoot, providerPath);
-                const operation = await classifyOperation(canonicalEntry, providerPath, entryStrategy, renderedContent);
+                    : manifestEntry?.strategy === 'symlink' ||
+                        manifestEntry?.strategy === 'copy'
+                        ? manifestEntry.strategy
+                        : mappingStrategy;
+                const operation = deferredCollectionTransition
+                    ? {
+                        operation: entryStrategy === 'copy'
+                            ? 'create_copy'
+                            : 'create_symlink',
+                        reason: 'collection alias will be safely detached before per-entry reconciliation',
+                    }
+                    : await (async () => {
+                        await assertSafeProviderMutationPath(entryScopeRoot, providerPath);
+                        return classifyOperation(canonicalEntry, providerPath, entryStrategy, renderedContent);
+                    })();
                 entries.push({
                     canonical: canonicalEntry,
                     provider: adapter.name,
@@ -370,21 +621,61 @@ export async function computeSyncPlan({ canonical, adapters, manifest, scope, co
                     strategy: entryStrategy,
                     reason: operation.reason,
                     renderedContent,
+                    ...(deferredCollectionTransition
+                        ? { deferredUntilCollectionDetached: true }
+                        : {}),
                 });
                 seenCanonicalKeys.add(`${normalize(relativeCanonicalPath)}::${adapter.name}`);
             }
         }
     }
     if (!scopeRoot) {
-        return { scope, entries, removals };
+        return { scope, entries, removals, collections };
     }
-    for (const manifestEntry of manifest.entries) {
-        if (!activeProviderNames.has(manifestEntry.provider)) {
+    for (const collection of manifest.collections) {
+        if (activeProviderNames.has(collection.provider)) {
+            continue;
+        }
+        const canonicalDir = resolve(scopeRoot, collection.canonicalDir);
+        const providerDir = resolve(scopeRoot, collection.providerDir);
+        const proof = await proveCollectionIdentity({
+            root: scopeRoot,
+            canonicalDir,
+            providerDir,
+        });
+        collections.push({
+            provider: collection.provider,
+            scope,
+            contentType: collection.contentType,
+            canonicalDir,
+            providerDir,
+            action: 'detach-collection',
+            ownership: collection.ownership,
+            configuredStrategy: 'auto',
+            proof,
+            createdLink: collection.createdLink,
+            inheritedEntries: manifestV2.entries
+                .filter((entry) => entry.strategy === 'collection' &&
+                entry.collectionId === collection.id)
+                .map((entry) => entry.canonicalPath),
+            reason: 'provider is disabled; reconcile collection ownership',
+        });
+    }
+    for (const manifestEntry of manifestV2.entries) {
+        if (manifestEntry.strategy === 'collection') {
+            if (!activeProviderNames.has(manifestEntry.provider)) {
+                continue;
+            }
+            const canonicalKey = `${normalize(manifestEntry.canonicalPath)}::${manifestEntry.provider}`;
+            if (!seenCanonicalKeys.has(canonicalKey)) {
+                removals.push(createCollectionDetachmentEntry(manifestEntry, scopeRoot));
+            }
             continue;
         }
-        if (scope === 'user' && manifestEntry.contentType === 'agent') {
+        if (!activeProviderNames.has(manifestEntry.provider)) {
             continue;
         }
+        const perEntryManifestEntry = manifestEntry;
         const canonicalKey = `${normalize(manifestEntry.canonicalPath)}::${manifestEntry.provider}`;
         if (seenCanonicalKeys.has(canonicalKey)) {
             continue;
@@ -393,14 +684,14 @@ export async function computeSyncPlan({ canonical, adapters, manifest, scope, co
             !canonicalFilter.has(normalize(manifestEntry.canonicalPath))) {
             continue;
         }
-        const mappingStillExists = (activeMappingsByProvider.get(manifestEntry.provider) ?? []).some((mapping) => manifestEntryInsideMapping(manifestEntry, mapping));
+        const mappingStillExists = (activeMappingsByProvider.get(manifestEntry.provider) ?? []).some((mapping) => manifestEntryInsideMapping(perEntryManifestEntry, mapping));
         const removal = mappingStillExists
-            ? createRemovalEntry(manifestEntry, scopeRoot)
-            : await classifyObsoleteMappingRetirement(manifestEntry, scopeRoot);
+            ? createRemovalEntry(perEntryManifestEntry, scopeRoot)
+            : await classifyObsoleteMappingRetirement(perEntryManifestEntry, scopeRoot);
         if (removal.operation === 'remove') {
             await assertSafeProviderMutationPath(scopeRoot, removal.providerPath);
         }
         removals.push(removal);
     }
-    return { scope, entries, removals };
+    return { scope, entries, removals, collections };
 }

package/dist/engine/engine.types.d.ts

@@ -1,5 +1,52 @@
 import type { Scope } from '../shared/types.js';
 import type { CanonicalEntry } from './scanner.js';
+export interface CollectionPathIdentity {
+    device: string;
+    inode: string;
+    type: 'directory' | 'symlink';
+    modifiedAtNanoseconds: string;
+}
+export interface CollectionLinkIdentity {
+    device: string;
+    inode: string;
+    linkText: string;
+}
+export type CollectionIdentityProof = {
+    status: 'absent';
+    canonicalDirectory: CollectionPathIdentity;
+    providerParent: CollectionPathIdentity;
+    checkedAt: string;
+} | {
+    status: 'exact-link';
+    providerLink: CollectionPathIdentity;
+    canonicalDirectory: CollectionPathIdentity;
+    linkTextKind: 'relative' | 'absolute';
+    linkText: string;
+    resolvedTarget: string;
+    entrySetDigest: string;
+    checkedAt: string;
+} | {
+    status: 'ineligible';
+    reason: 'real-directory' | 'broken-link' | 'foreign-target' | 'divergent-entries' | 'unsafe-ancestry' | 'identity-unavailable';
+    observedIdentity?: CollectionPathIdentity;
+    checkedAt: string;
+};
+export type CollectionSyncAction = 'create-collection-link' | 'adopt-collection-link' | 'inherit-collection' | 'fallback-per-entry' | 'detach-collection' | 'reject-collection';
+export interface CollectionProjectionPlan {
+    provider: string;
+    scope: EngineScope;
+    contentType: CanonicalEntry['type'];
+    canonicalDir: string;
+    providerDir: string;
+    action: CollectionSyncAction;
+    ownership: 'oat-created' | 'adopted-exact' | 'none';
+    configuredStrategy: 'auto' | 'symlink' | 'copy';
+    createdLink?: CollectionLinkIdentity;
+    transitionToPerEntry?: boolean;
+    proof: CollectionIdentityProof;
+    inheritedEntries: readonly string[];
+    reason: string;
+}
 export type EngineScope = Exclude<Scope, 'all'>;
 export declare const SYNC_OPERATION_TYPES: readonly ['create_symlink', 'create_copy', 'update_symlink', 'update_copy', 'remove', 'detach', 'skip'];
 export type SyncOperationType = (typeof SYNC_OPERATION_TYPES)[number];
@@ -11,6 +58,7 @@ export interface SyncPlanEntry {
     strategy: 'symlink' | 'copy';
     reason: string;
     renderedContent?: string;
+    deferredUntilCollectionDetached?: boolean;
 }
 export type RemovalSyncPlanEntry = SyncPlanEntry & {
     operation: 'remove' | 'detach';
@@ -19,10 +67,23 @@ export interface SyncPlan {
     scope: EngineScope;
     entries: SyncPlanEntry[];
     removals: RemovalSyncPlanEntry[];
+    collections?: CollectionProjectionPlan[];
+}
+export type SyncOperationStatus = 'planned' | 'changed' | 'current' | 'missing' | 'failed' | 'unsupported' | 'unknown';
+export interface SyncOperationResult {
+    scope: EngineScope;
+    provider: string;
+    contentKind: CanonicalEntry['type'];
+    asset: string;
+    action: SyncOperationType;
+    status: SyncOperationStatus;
+    failure?: string;
 }
 export interface SyncResult {
     applied: number;
     failed: number;
     skipped: number;
+    /** Additive per-operation evidence; optional for legacy execution adapters. */
+    operations?: SyncOperationResult[];
 }
 //# sourceMappingURL=engine.types.d.ts.map

package/dist/engine/engine.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.types.d.ts","sourceRoot":"","sources":["../../src/engine/engine.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAEhD,eAAO,MAAM,oBAAoB,YAC/B,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,MAAM,CACE,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,QAAQ,EAAE,SAAS,GAAG,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IACjD,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAChC,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,oBAAoB,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB"}
+{"version":3,"file":"engine.types.d.ts","sourceRoot":"","sources":["../../src/engine/engine.types.ts"],"names":[],"mappings":"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"}

package/dist/engine/execute-plan.d.ts

@@ -1,9 +1,29 @@
+import { copyDirectory, createCollectionSymlinkNoClobber, createSymlinkNoClobber, removeCollectionSymlinkIfUnchanged } from '../fs/io.js';
+import { saveManifest as persistManifest } from '../manifest/manager.js';
 import type { Manifest } from '../manifest/manifest.types.js';
-import type { SyncPlan, SyncResult } from './engine.types.js';
+import { proveCollectionIdentity } from './collection-sync.js';
+import type { CollectionProjectionPlan, SyncPlan, SyncResult } from './engine.types.js';
 interface ExecuteSyncPlanDependencies {
     beforeFirstMutation?: () => Promise<void>;
+    saveManifest?: typeof persistManifest;
+    copyDirectory?: typeof copyDirectory;
+    createSymlinkNoClobber?: typeof createSymlinkNoClobber;
+    createCollectionSymlinkNoClobber?: typeof createCollectionSymlinkNoClobber;
+    removeCollectionSymlinkIfUnchanged?: typeof removeCollectionSymlinkIfUnchanged;
+    proveCollectionIdentity?: typeof proveCollectionIdentity;
 }
+export interface CollectionOperationResult {
+    provider: string;
+    contentType: CollectionProjectionPlan['contentType'];
+    action: CollectionProjectionPlan['action'];
+    ownership: CollectionProjectionPlan['ownership'];
+    status: 'changed' | 'current' | 'fallback' | 'rejected' | 'failed' | 'partial';
+    reason: string;
+}
+export type CollectionSyncResult = SyncResult & {
+    collectionResults: CollectionOperationResult[];
+};
 export declare function inferScopeRoot(canonicalPath: string): string;
-export declare function executeSyncPlan(plan: SyncPlan, manifest: Manifest, manifestPath: string, dependencies?: ExecuteSyncPlanDependencies): Promise<SyncResult>;
+export declare function executeSyncPlan(plan: SyncPlan, manifest: Manifest, manifestPath: string, dependencies?: ExecuteSyncPlanDependencies): Promise<CollectionSyncResult>;
 export {};
 //# sourceMappingURL=execute-plan.d.ts.map

package/dist/engine/execute-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute-plan.d.ts","sourceRoot":"","sources":["../../src/engine/execute-plan.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,0BAA0B,CAAC;AAExE,OAAO,KAAK,EAAE,QAAQ,EAAiB,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAI1E,UAAU,2BAA2B;IACnC,mBAAmB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAeD,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAW5D;AA2JD,wBAAsB,eAAe,CACnC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,MAAM,EACpB,YAAY,GAAE,2BAAoE,GACjF,OAAO,CAAC,UAAU,CAAC,CAwCrB"}
+{"version":3,"file":"execute-plan.d.ts","sourceRoot":"","sources":["../../src/engine/execute-plan.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,aAAa,EAGb,gCAAgC,EAEhC,sBAAsB,EACtB,kCAAkC,EAGnC,MAAM,QAAQ,CAAC;AAEhB,OAAO,EAAE,YAAY,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EACV,QAAQ,EAGT,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAGL,uBAAuB,EACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,wBAAwB,EAExB,QAAQ,EAER,UAAU,EACX,MAAM,gBAAgB,CAAC;AAIxB,UAAU,2BAA2B;IACnC,mBAAmB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,YAAY,CAAC,EAAE,OAAO,eAAe,CAAC;IACtC,aAAa,CAAC,EAAE,OAAO,aAAa,CAAC;IACrC,sBAAsB,CAAC,EAAE,OAAO,sBAAsB,CAAC;IACvD,gCAAgC,CAAC,EAAE,OAAO,gCAAgC,CAAC;IAC3E,kCAAkC,CAAC,EAAE,OAAO,kCAAkC,CAAC;IAC/E,uBAAuB,CAAC,EAAE,OAAO,uBAAuB,CAAC;CAC1D;AAID,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,wBAAwB,CAAC,aAAa,CAAC,CAAC;IACrD,MAAM,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAC3C,SAAS,EAAE,wBAAwB,CAAC,WAAW,CAAC,CAAC;IACjD,MAAM,EACF,SAAS,GACT,SAAS,GACT,UAAU,GACV,UAAU,GACV,QAAQ,GACR,SAAS,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG;IAC9C,iBAAiB,EAAE,yBAAyB,EAAE,CAAC;CAChD,CAAC;AAiFF,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAW5D;AAiqBD,wBAAsB,eAAe,CACnC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,MAAM,EACpB,YAAY,GAAE,2BAAoE,GACjF,OAAO,CAAC,oBAAoB,CAAC,CA+J/B"}