@open-agent-toolkit/cli 0.2.36 → 0.2.37

package/dist/commands/tools/remove/remove-tools.js

@@ -1,5 +1,7 @@
 import { join } from 'node:path';
-import { WORKFLOW_AGENTS, WORKFLOW_SCRIPTS, WORKFLOW_TEMPLATES, } from '../../init/tools/shared/skill-manifest.js';
+import { PACK_MANIFEST } from '../../tools/shared/pack-manifest.js';
+import { resolveSharedOwnerRetentions } from '../../tools/shared/pack-reconcile.js';
+import { resolveManagedScopeRoots, validateManagedPath, } from '../../../fs/paths.js';
 function matchesTarget(tool, target) {
     switch (target.kind) {
         case 'name':
@@ -22,43 +24,171 @@ async function removeTool(tool, scopeRoot, dryRun, deps) {
         await deps.removeDirectory(skillPath);
     }
 }
-async function removePackCompanionAssets(pack, scope, scopeRoot, dryRun, deps) {
-    if (dryRun || pack !== 'workflows' || scope !== 'user') {
-        return;
+function isDirectoryAsset(asset) {
+    return asset.kind === 'skill' || asset.kind === 'directory';
+}
+function selectedPacks(target) {
+    return target.kind === 'pack'
+        ? [target.pack]
+        : PACK_MANIFEST.map(({ name }) => name);
+}
+function selectedManagedAssets(packs, scope) {
+    return PACK_MANIFEST.filter(({ name }) => packs.includes(name)).flatMap(({ name, assets }) => assets
+        .filter((asset) => asset.scopes.includes(scope) &&
+        asset.ownership[scope] === 'managed')
+        .map((asset) => ({ pack: name, asset })));
+}
+function managedRootName(asset) {
+    const name = asset.destination.split('/')[0];
+    if (name !== '.agents' && name !== '.oat') {
+        throw new Error(`Pack asset ${asset.id} has unsupported managed root: ${asset.destination}`);
     }
-    for (const agent of WORKFLOW_AGENTS) {
-        await deps.removeFile(join(scopeRoot, '.agents', 'agents', agent));
+    return name;
+}
+async function planManagedPackRemoval(packs, scope, scopeRoot, dryRun, deps) {
+    const retentions = await resolveSharedOwnerRetentions({
+        packs,
+        scope,
+        scopeRoot,
+        hasOwnershipEvidence: deps.hasPackOwnershipEvidence,
+    });
+    const retainedPaths = new Set(retentions.map(({ path }) => path));
+    const managedAssets = selectedManagedAssets(packs, scope);
+    // Sampled before anything is deleted, because that is the only moment at
+    // which a pack's physical footprint is still observable. Retained
+    // shared-owner assets count: the pack declares them, so a removal that had to
+    // consider them is not a no-op for that pack.
+    const assetPaths = new Map();
+    for (const { asset } of managedAssets) {
+        assetPaths.set(asset.destination, join(scopeRoot, asset.destination));
     }
-    for (const template of WORKFLOW_TEMPLATES) {
-        await deps.removeFile(join(scopeRoot, '.oat', 'templates', template));
+    const existence = new Map(await Promise.all([...assetPaths.values()].map(async (path) => [
+        path,
+        await deps.pathExists(path),
+    ])));
+    const presentPacks = [
+        ...new Set(managedAssets
+            .filter(({ asset }) => existence.get(assetPaths.get(asset.destination)))
+            .map(({ pack }) => pack)),
+    ];
+    const targets = new Map();
+    for (const { asset } of managedAssets) {
+        const path = join(scopeRoot, asset.destination);
+        if (targets.has(path) || retainedPaths.has(path))
+            continue;
+        targets.set(path, { asset, isDirectory: isDirectoryAsset(asset) });
     }
-    for (const script of WORKFLOW_SCRIPTS) {
-        await deps.removeFile(join(scopeRoot, '.oat', 'scripts', script));
+    const retained = [...retainedPaths].map((path) => ({
+        path,
+        reason: 'retained shared owner data',
+    }));
+    if (dryRun) {
+        return {
+            targets: [...targets.entries()].map(([path, { isDirectory }]) => ({
+                path,
+                isDirectory,
+            })),
+            retained,
+            presentPacks,
+        };
+    }
+    const roots = await resolveManagedScopeRoots(scopeRoot);
+    return {
+        targets: await Promise.all([...targets.entries()].map(async ([path, { asset, isDirectory },]) => {
+            await validateManagedPath(path, roots[managedRootName(asset)]);
+            return { path, isDirectory };
+        })),
+        retained,
+        presentPacks,
+    };
+}
+async function executeManagedPackRemoval(targets, deps) {
+    for (const target of targets) {
+        if (target.isDirectory) {
+            await deps.removeDirectory(target.path);
+        }
+        else {
+            await deps.removeFile(target.path);
+        }
+    }
+    const remaining = (await Promise.all(targets.map(async ({ path }) => (await deps.pathExists(path)) ? path : null))).filter((path) => path !== null);
+    if (remaining.length > 0) {
+        throw new Error(`Managed pack removal incomplete; assets remain: ${remaining.join(', ')}`);
     }
 }
 export async function removeTools(target, scopes, cwd, home, dryRun, deps) {
     const removed = [];
+    const removedAssets = [];
+    const retainedOwnerData = [];
     const assetsRoot = await deps.resolveAssetsRoot();
+    if (target.kind === 'name') {
+        for (const scope of scopes) {
+            const scopeRoot = await deps.resolveScopeRoot(scope, cwd, home);
+            const tools = await deps.scanTools({ scope, scopeRoot, assetsRoot });
+            const matched = tools.filter((tool) => matchesTarget(tool, target));
+            for (const tool of matched) {
+                await removeTool(tool, scopeRoot, dryRun, deps);
+                removed.push({ name: tool.name, type: tool.type, scope: tool.scope });
+            }
+        }
+        return {
+            removed,
+            removedAssets,
+            retainedOwnerData,
+            packOutcomes: [],
+            notInstalled: removed.length === 0 ? [target.name] : [],
+        };
+    }
+    const packOutcomes = [];
+    const plans = [];
     for (const scope of scopes) {
         const scopeRoot = await deps.resolveScopeRoot(scope, cwd, home);
         const tools = await deps.scanTools({ scope, scopeRoot, assetsRoot });
-        const matched = tools.filter((t) => matchesTarget(t, target));
-        for (const tool of matched) {
-            await removeTool(tool, scopeRoot, dryRun, deps);
-            removed.push({ name: tool.name, type: tool.type, scope: tool.scope });
-        }
-        if (target.kind !== 'name') {
-            const matchedPacks = new Set(matched
-                .map((tool) => tool.pack)
-                .filter((pack) => pack !== 'custom'));
-            for (const pack of matchedPacks) {
-                await removePackCompanionAssets(pack, scope, scopeRoot, dryRun, deps);
+        const matched = tools.filter((tool) => matchesTarget(tool, target));
+        const managedPlan = await planManagedPackRemoval(selectedPacks(target), scope, scopeRoot, dryRun, deps);
+        const seedData = PACK_MANIFEST.filter(({ name }) => selectedPacks(target).includes(name)).flatMap(({ assets }) => assets
+            .filter((asset) => asset.scopes.includes(scope) &&
+            asset.ownership[scope] === 'seed-if-missing')
+            .map(({ destination }) => ({
+            path: join(scopeRoot, destination),
+            reason: 'repository or scope owner data',
+        })));
+        plans.push({
+            scope,
+            scopeRoot,
+            matched,
+            managedTargets: managedPlan.targets,
+            retainedOwnerData: [...managedPlan.retained, ...seedData],
+            presentPacks: managedPlan.presentPacks,
+        });
+    }
+    for (const plan of plans) {
+        if (target.kind === 'all') {
+            for (const tool of plan.matched.filter(({ pack }) => pack === 'custom')) {
+                await removeTool(tool, plan.scopeRoot, dryRun, deps);
             }
         }
+        if (!dryRun) {
+            await executeManagedPackRemoval(plan.managedTargets, deps);
+        }
+        removed.push(...plan.matched.map(({ name, type, scope }) => ({ name, type, scope })));
+        removedAssets.push(...plan.managedTargets.map(({ path }) => ({ path, scope: plan.scope })));
+        retainedOwnerData.push(...plan.retainedOwnerData.map((entry) => ({
+            ...entry,
+            scope: plan.scope,
+        })));
+        packOutcomes.push(...selectedPacks(target).map((pack) => ({
+            pack,
+            scope: plan.scope,
+            removed: plan.matched.some((tool) => tool.pack === pack) ||
+                plan.presentPacks.includes(pack),
+        })));
     }
-    const notInstalled = [];
-    if (target.kind === 'name' && removed.length === 0) {
-        notInstalled.push(target.name);
-    }
-    return { removed, notInstalled };
+    return {
+        removed,
+        removedAssets,
+        retainedOwnerData,
+        packOutcomes,
+        notInstalled: [],
+    };
 }

package/dist/commands/tools/shared/apply-pack-reconcile.d.ts

@@ -0,0 +1,41 @@
+import { type ManagedRootName, type ResolvedManagedRoot } from '../../../fs/paths.js';
+import type { ScopedPackInventory } from './pack-inventory.js';
+import type { PackReconcileOperation, PackReconcilePlan } from './pack-reconcile.js';
+export interface ApplyPackReconcileDependencies {
+    resolveManagedRoots?: (scopeRoot: string) => Promise<Record<ManagedRootName, ResolvedManagedRoot>>;
+    validatePath?: (candidatePath: string, managedRoot: ResolvedManagedRoot) => Promise<{
+        realManagedRoot: string;
+        realPath: string;
+    }>;
+    copyDirectory?: (source: string, destination: string, force: boolean) => Promise<unknown>;
+    copyFile?: (source: string, destination: string, force: boolean) => Promise<unknown>;
+    removePath?: (path: string, directory: boolean) => Promise<void>;
+    chmodPath?: (path: string, mode: number) => Promise<void>;
+    writeGenerated: (operation: Extract<PackReconcileOperation, {
+        kind: 'write-generated';
+    }>) => Promise<void>;
+    writeIntent: (operation: Extract<PackReconcileOperation, {
+        kind: 'write-intent';
+    }>) => Promise<void>;
+    inventory: () => Promise<ScopedPackInventory>;
+    sync?: (input: {
+        scope: PackReconcilePlan['scope'];
+        action: PackReconcilePlan['action'];
+        changedCanonicalPaths: readonly string[];
+    }) => Promise<void>;
+}
+export interface ApplyPackReconcileResult {
+    applied: readonly PackReconcileOperation[];
+    inventory: ScopedPackInventory;
+    synced: boolean;
+}
+export interface PackReconcilePreflightDependencies {
+    resolveManagedRoots?: ApplyPackReconcileDependencies['resolveManagedRoots'];
+    validatePath?: ApplyPackReconcileDependencies['validatePath'];
+}
+export declare function preflightPackReconcilePlans(entries: readonly {
+    plan: PackReconcilePlan;
+    scopeRoot: string;
+}[], dependencies?: PackReconcilePreflightDependencies): Promise<void>;
+export declare function applyPackReconcilePlan(plan: PackReconcilePlan, scopeRoot: string, dependencies: ApplyPackReconcileDependencies): Promise<ApplyPackReconcileResult>;
+//# sourceMappingURL=apply-pack-reconcile.d.ts.map

package/dist/commands/tools/shared/apply-pack-reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-pack-reconcile.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/apply-pack-reconcile.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAGzB,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EACV,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,8BAA8B;IAC7C,mBAAmB,CAAC,EAAE,CACpB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAC3D,YAAY,CAAC,EAAE,CACb,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,mBAAmB,KAC7B,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5D,aAAa,CAAC,EAAE,CACd,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,QAAQ,CAAC,EAAE,CACT,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,cAAc,EAAE,CACd,SAAS,EAAE,OAAO,CAAC,sBAAsB,EAAE;QAAE,IAAI,EAAE,iBAAiB,CAAA;KAAE,CAAC,KACpE,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,WAAW,EAAE,CACX,SAAS,EAAE,OAAO,CAAC,sBAAsB,EAAE;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC,KACjE,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,SAAS,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC9C,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE;QACb,KAAK,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAClC,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QACpC,qBAAqB,EAAE,SAAS,MAAM,EAAE,CAAC;KAC1C,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC3C,SAAS,EAAE,mBAAmB,CAAC;IAC/B,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,kCAAkC;IACjD,mBAAmB,CAAC,EAAE,8BAA8B,CAAC,qBAAqB,CAAC,CAAC;IAC5E,YAAY,CAAC,EAAE,8BAA8B,CAAC,cAAc,CAAC,CAAC;CAC/D;AAwBD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,SAAS;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,EAClE,YAAY,GAAE,kCAAuC,GACpD,OAAO,CAAC,IAAI,CAAC,CAsBf;AA2BD,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,iBAAiB,EACvB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,8BAA8B,GAC3C,OAAO,CAAC,wBAAwB,CAAC,CAoFnC"}

package/dist/commands/tools/shared/apply-pack-reconcile.js

@@ -0,0 +1,126 @@
+import { chmod, rm } from 'node:fs/promises';
+import { copyDirWithStatus, copyFileWithStatus, } from '../../init/tools/shared/copy-helpers.js';
+import { resolveManagedScopeRoots, validateManagedPath, } from '../../../fs/paths.js';
+function operationPath(operation) {
+    switch (operation.kind) {
+        case 'copy-dir':
+        case 'copy-file':
+        case 'write-generated':
+            return operation.destination;
+        case 'chmod':
+        case 'remove-dir':
+        case 'remove-file':
+            return operation.path;
+        case 'write-intent':
+            return null;
+    }
+}
+function managedRootForPath(path) {
+    const normalized = path.replaceAll('\\', '/');
+    if (normalized.includes('/.agents/'))
+        return '.agents';
+    if (normalized.includes('/.oat/'))
+        return '.oat';
+    throw new Error(`Pack reconcile path is outside a managed root: ${path}`);
+}
+export async function preflightPackReconcilePlans(entries, dependencies = {}) {
+    const resolveRoots = dependencies.resolveManagedRoots ?? resolveManagedScopeRoots;
+    const validate = dependencies.validatePath ?? validateManagedPath;
+    const rootsByScope = new Map();
+    for (const { plan, scopeRoot } of entries) {
+        let roots = rootsByScope.get(scopeRoot);
+        if (!roots) {
+            roots = await resolveRoots(scopeRoot);
+            rootsByScope.set(scopeRoot, roots);
+        }
+        const seen = new Set();
+        for (const operation of plan.operations) {
+            const path = operationPath(operation);
+            if (!path || seen.has(path))
+                continue;
+            await validate(path, roots[managedRootForPath(path)]);
+            seen.add(path);
+        }
+    }
+}
+function assertExpectedInventory(plan, inventory) {
+    if (inventory.pack !== plan.pack ||
+        inventory.scope !== plan.scope ||
+        inventory.completeness !== plan.expectedCompleteness) {
+        throw new Error(`Pack ${plan.pack} ${plan.scope} verification expected ${plan.expectedCompleteness} but found ${inventory.completeness}`);
+    }
+    if (plan.action === 'remove')
+        return;
+    const drifted = inventory.assets.filter(({ definition, status }) => definition.ownership[plan.scope] === 'managed' && status !== 'current');
+    if (drifted.length > 0) {
+        throw new Error(`Pack ${plan.pack} ${plan.scope} verification found drifted managed assets: ${drifted.map(({ definition, status }) => `${definition.id} (${status})`).join(', ')}`);
+    }
+}
+export async function applyPackReconcilePlan(plan, scopeRoot, dependencies) {
+    const resolveRoots = dependencies.resolveManagedRoots ?? resolveManagedScopeRoots;
+    const validate = dependencies.validatePath ?? validateManagedPath;
+    const roots = await resolveRoots(scopeRoot);
+    const validatedPaths = new Map();
+    // Validate every planned filesystem target before the first mutation.
+    for (const operation of plan.operations) {
+        const path = operationPath(operation);
+        if (!path || validatedPaths.has(path))
+            continue;
+        const { realPath } = await validate(path, roots[managedRootForPath(path)]);
+        validatedPaths.set(path, realPath);
+    }
+    const applied = [];
+    const intents = [];
+    for (const operation of plan.operations) {
+        if (operation.kind === 'write-intent') {
+            intents.push(operation);
+            continue;
+        }
+        const path = operationPath(operation);
+        if (!path)
+            continue;
+        const realPath = validatedPaths.get(path);
+        if (!realPath)
+            throw new Error(`Missing validated path for ${path}`);
+        switch (operation.kind) {
+            case 'copy-dir':
+                await (dependencies.copyDirectory ?? copyDirWithStatus)(operation.source, realPath, operation.force);
+                break;
+            case 'copy-file':
+                await (dependencies.copyFile ?? copyFileWithStatus)(operation.source, realPath, operation.force);
+                break;
+            case 'write-generated':
+                await dependencies.writeGenerated({
+                    ...operation,
+                    destination: realPath,
+                });
+                break;
+            case 'chmod':
+                await (dependencies.chmodPath ?? chmod)(realPath, operation.mode);
+                break;
+            case 'remove-dir':
+            case 'remove-file':
+                await (dependencies.removePath ??
+                    (async (target, directory) => rm(target, { recursive: directory, force: true })))(realPath, operation.kind === 'remove-dir');
+                break;
+        }
+        applied.push(operation);
+    }
+    const verifiedInventory = await dependencies.inventory();
+    assertExpectedInventory(plan, verifiedInventory);
+    for (const intent of intents) {
+        await dependencies.writeIntent(intent);
+        applied.push(intent);
+    }
+    const inventory = intents.length > 0 ? await dependencies.inventory() : verifiedInventory;
+    assertExpectedInventory(plan, inventory);
+    const shouldSync = plan.changedCanonicalPaths.length > 0 && dependencies.sync;
+    if (shouldSync) {
+        await dependencies.sync({
+            scope: plan.scope,
+            action: plan.action,
+            changedCanonicalPaths: plan.changedCanonicalPaths,
+        });
+    }
+    return { applied, inventory, synced: Boolean(shouldSync) };
+}

package/dist/commands/tools/shared/auto-sync.d.ts

@@ -6,6 +6,7 @@ export interface AutoSyncDependencies {
         cwd: string;
         home: string;
         installedCanonicalPaths?: string[];
+        removedCanonicalPaths?: string[];
     }) => Promise<void>;
 }
 export interface AutoSyncResult {
@@ -13,7 +14,9 @@ export interface AutoSyncResult {
     scopes: ConcreteScope[];
     error: string | null;
 }
-export declare function autoSync(scopes: ConcreteScope[], cwd: string, home: string, logger: CliLogger, dependencies: AutoSyncDependencies, options?: {
+export interface AutoSyncOptions {
     installedCanonicalPaths?: string[];
-}): Promise<AutoSyncResult>;
+    removedCanonicalPaths?: string[];
+}
+export declare function autoSync(scopes: ConcreteScope[], cwd: string, home: string, logger: CliLogger, dependencies: AutoSyncDependencies, options?: AutoSyncOptions): Promise<AutoSyncResult>;
 //# sourceMappingURL=auto-sync.d.ts.map

package/dist/commands/tools/shared/auto-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/auto-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,CAAC,OAAO,EAAE;QACjB,KAAK,EAAE,aAAa,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;KACpC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE,oBAAoB,EAClC,OAAO,CAAC,EAAE;IAAE,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/C,OAAO,CAAC,cAAc,CAAC,CAqBzB"}
+{"version":3,"file":"auto-sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/auto-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,CAAC,OAAO,EAAE;QACjB,KAAK,EAAE,aAAa,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;QACnC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;KAClC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE,oBAAoB,EAClC,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,CAAC,CAsBzB"}

package/dist/commands/tools/shared/auto-sync.js

@@ -9,6 +9,7 @@ export async function autoSync(scopes, cwd, home, logger, dependencies, options)
                 cwd,
                 home,
                 installedCanonicalPaths: options?.installedCanonicalPaths,
+                removedCanonicalPaths: options?.removedCanonicalPaths,
             });
         }
         logger.info('Auto-sync completed.');

package/dist/commands/tools/shared/content-digest.d.ts

@@ -0,0 +1,3 @@
+export declare function digestFile(path: string, normalizedMode?: number): Promise<string>;
+export declare function digestDirectory(root: string): Promise<string>;
+//# sourceMappingURL=content-digest.d.ts.map

package/dist/commands/tools/shared/content-digest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-digest.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/content-digest.ts"],"names":[],"mappings":"AAaA,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA4CnE"}

package/dist/commands/tools/shared/content-digest.js

@@ -0,0 +1,57 @@
+import { createHash } from 'node:crypto';
+import { lstat, readFile, readdir, readlink } from 'node:fs/promises';
+import { join } from 'node:path';
+function executableMode(mode) {
+    return (mode & 0o111).toString(8);
+}
+function updateField(hash, value) {
+    hash.update(`${Buffer.byteLength(value)}:`);
+    hash.update(value);
+}
+export async function digestFile(path, normalizedMode) {
+    const [content, metadata] = await Promise.all([readFile(path), lstat(path)]);
+    const hash = createHash('sha256');
+    updateField(hash, 'file');
+    updateField(hash, executableMode(normalizedMode ?? metadata.mode));
+    hash.update(`${content.length}:`);
+    hash.update(content);
+    return hash.digest('hex');
+}
+export async function digestDirectory(root) {
+    const hash = createHash('sha256');
+    async function visit(directory, relativeRoot) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const path = join(directory, entry.name);
+            const relativePath = relativeRoot
+                ? `${relativeRoot}/${entry.name}`
+                : entry.name;
+            const metadata = await lstat(path);
+            if (entry.isDirectory()) {
+                updateField(hash, 'directory');
+                updateField(hash, relativePath);
+                await visit(path, relativePath);
+                continue;
+            }
+            if (entry.isFile()) {
+                const content = await readFile(path);
+                updateField(hash, 'file');
+                updateField(hash, relativePath);
+                updateField(hash, executableMode(metadata.mode));
+                hash.update(`${content.length}:`);
+                hash.update(content);
+                continue;
+            }
+            if (entry.isSymbolicLink()) {
+                updateField(hash, 'symlink');
+                updateField(hash, relativePath);
+                updateField(hash, await readlink(path));
+                continue;
+            }
+            throw new Error(`Unsupported filesystem entry in pack asset: ${path}`);
+        }
+    }
+    await visit(root, '');
+    return hash.digest('hex');
+}

package/dist/commands/tools/shared/format-pack-inventory.d.ts

@@ -0,0 +1,3 @@
+import type { PackInventory } from './pack-inventory.js';
+export declare function formatPackInventoryDetails(inventory: PackInventory, indent?: string): string[];
+//# sourceMappingURL=format-pack-inventory.d.ts.map

package/dist/commands/tools/shared/format-pack-inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-pack-inventory.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/format-pack-inventory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAUtD,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,aAAa,EACxB,MAAM,SAAO,GACZ,MAAM,EAAE,CAuBV"}

package/dist/commands/tools/shared/format-pack-inventory.js

@@ -0,0 +1,21 @@
+function versionEvidence(installed, bundled) {
+    if (installed === null && bundled === null)
+        return '';
+    return `; versions=${installed ?? '-'} -> ${bundled ?? '-'}`;
+}
+export function formatPackInventoryDetails(inventory, indent = '  ') {
+    const lines = [];
+    for (const scoped of inventory.scopes) {
+        lines.push(`${indent}${scoped.scope}: ${scoped.completeness}; intent=${scoped.intent.source}`);
+        for (const asset of scoped.assets) {
+            lines.push(`${indent}  ${asset.definition.id} [${asset.definition.kind}] ${asset.status}; path=${asset.path}${versionEvidence(asset.installedVersion, asset.bundledVersion)}`);
+        }
+    }
+    for (const diagnostic of inventory.diagnostics) {
+        lines.push(`${indent}diagnostic ${diagnostic.code}: ${diagnostic.message}; paths=${diagnostic.paths.join(', ') || '-'}`);
+        if (diagnostic.versions) {
+            lines.push(`${indent}  versions=${diagnostic.versions.map((version) => version ?? '-').join(', ')}`);
+        }
+    }
+    return lines;
+}

package/dist/commands/tools/shared/install-sync-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"install-sync-context.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/install-sync-context.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAI3E;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAI3E;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAyB9D;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,EAAE,CAI3E;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,IAAI,CAMN;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAGrE"}
+{"version":3,"file":"install-sync-context.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/install-sync-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUzC,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAI3E;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAI3E;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAE9D;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,EAAE,CAI3E;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,IAAI,CAMN;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAGrE"}

package/dist/commands/tools/shared/install-sync-context.js

@@ -1,4 +1,4 @@
-import { BRAINSTORM_SKILLS, CORE_SKILLS, DOCS_SKILLS, IDEA_SKILLS, PROJECT_MANAGEMENT_SKILLS, RESEARCH_AGENTS, RESEARCH_SKILLS, UTILITY_SKILLS, WORKFLOW_AGENTS, WORKFLOW_SKILLS, } from '../../init/tools/shared/skill-manifest.js';
+import { getCanonicalProviderPaths } from './pack-manifest.js';
 const INSTALL_SYNC_CANONICAL_PATHS = Symbol('oat.installSyncCanonicalPaths');
 function uniqueCanonicalPaths(paths) {
     return [...new Set(paths)];
@@ -10,30 +10,7 @@ export function canonicalAgentPaths(agentNames) {
     return uniqueCanonicalPaths(agentNames.map((agentName) => `.agents/agents/${agentName}`));
 }
 export function canonicalPathsForPack(pack) {
-    switch (pack) {
-        case 'core':
-            return canonicalSkillPaths(CORE_SKILLS);
-        case 'ideas':
-            return canonicalSkillPaths(IDEA_SKILLS);
-        case 'docs':
-            return canonicalSkillPaths(DOCS_SKILLS);
-        case 'workflows':
-            return uniqueCanonicalPaths([
-                ...canonicalSkillPaths(WORKFLOW_SKILLS),
-                ...canonicalAgentPaths(WORKFLOW_AGENTS),
-            ]);
-        case 'utility':
-            return canonicalSkillPaths(UTILITY_SKILLS);
-        case 'project-management':
-            return canonicalSkillPaths(PROJECT_MANAGEMENT_SKILLS);
-        case 'research':
-            return uniqueCanonicalPaths([
-                ...canonicalSkillPaths(RESEARCH_SKILLS),
-                ...canonicalAgentPaths(RESEARCH_AGENTS),
-            ]);
-        case 'brainstorm':
-            return canonicalSkillPaths(BRAINSTORM_SKILLS);
-    }
+    return getCanonicalProviderPaths(pack);
 }
 export function canonicalPathsForPacks(packs) {
     return uniqueCanonicalPaths(packs.flatMap((pack) => canonicalPathsForPack(pack)));

package/dist/commands/tools/shared/pack-inventory.d.ts

@@ -0,0 +1,46 @@
+import { type ConcreteScope } from '../../../shared/types.js';
+import { type ScopedPackIntent } from './scoped-pack-intent.js';
+import type { PackAssetDefinition, PackAssetStatus, PackCompleteness, PackName } from './types.js';
+export interface PackAssetInventory {
+    definition: PackAssetDefinition;
+    path: string;
+    status: PackAssetStatus;
+    installedVersion: string | null;
+    bundledVersion: string | null;
+}
+export interface PackDiagnostic {
+    code: 'legacy-false-conflict' | 'duplicate-scope' | 'shared-owner-observation' | 'user-agent-unmaterialized';
+    message: string;
+    paths: string[];
+    versions?: Array<string | null>;
+}
+export interface ScopedPackInventory {
+    pack: PackName;
+    scope: ConcreteScope;
+    intent: ScopedPackIntent;
+    completeness: PackCompleteness;
+    assets: PackAssetInventory[];
+    diagnostics: PackDiagnostic[];
+}
+export interface PackInventory {
+    pack: PackName;
+    placement: 'project' | 'user' | 'both' | 'unavailable';
+    scopes: ScopedPackInventory[];
+    diagnostics: PackDiagnostic[];
+}
+export interface InventoryScopedPackInput {
+    pack: PackName;
+    scope: ConcreteScope;
+    scopeRoot: string;
+    assetsRoot: string;
+}
+export interface InventoryPackInput {
+    pack: PackName;
+    assetsRoot: string;
+    projectRoot?: string;
+    userRoot?: string;
+}
+export declare function inventoryScopedPack(input: InventoryScopedPackInput): Promise<ScopedPackInventory>;
+export declare function hasScopedPackPlacementEvidence(inventory: ScopedPackInventory): boolean;
+export declare function inventoryPack(input: InventoryPackInput): Promise<PackInventory>;
+//# sourceMappingURL=pack-inventory.d.ts.map

package/dist/commands/tools/shared/pack-inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-inventory.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-inventory.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AAIvB,OAAO,EAEL,KAAK,gBAAgB,EAEtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACT,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,mBAAmB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,eAAe,CAAC;IACxB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EACA,uBAAuB,GACvB,iBAAiB,GACjB,0BAA0B,GAC1B,2BAA2B,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,WAAW,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC;IACvD,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,WAAW,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA0KD,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,mBAAmB,CAAC,CAmC9B;AAED,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAUT;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,aAAa,CAAC,CA0DxB"}