@open-agent-toolkit/cli 0.2.36 → 0.2.37

package/dist/commands/tools/migrate/migrate-pack.js

@@ -0,0 +1,324 @@
+import { applyPackReconcilePlan, } from '../../tools/shared/apply-pack-reconcile.js';
+import { hasScopedPackPlacementEvidence, } from '../../tools/shared/pack-inventory.js';
+import { getPackDefinition } from '../../tools/shared/pack-manifest.js';
+import { planPackReconcile, } from '../../tools/shared/pack-reconcile.js';
+function assertInventory(inventory, pack, scope, label) {
+    if (inventory.pack !== pack || inventory.scope !== scope) {
+        throw new Error(`Migration ${label} inventory does not match pack ${pack} at ${scope} scope`);
+    }
+}
+function previewAsset(asset, scope, reason) {
+    return {
+        assetId: asset.definition.id,
+        kind: asset.definition.kind,
+        scope,
+        path: asset.path,
+        status: asset.status,
+        ...(reason ? { reason } : {}),
+    };
+}
+export function planPackMigration(input) {
+    if (input.from === input.to) {
+        throw new Error('Migration source and destination scopes must differ');
+    }
+    const packDefinition = getPackDefinition(input.pack);
+    if (!packDefinition.allowedScopes.includes(input.from)) {
+        throw new Error(`Pack ${input.pack} does not allow ${input.from} source scope`);
+    }
+    if (!packDefinition.allowedScopes.includes(input.to)) {
+        throw new Error(`Pack ${input.pack} does not allow ${input.to} destination scope`);
+    }
+    assertInventory(input.sourceInventory, input.pack, input.from, 'source');
+    assertInventory(input.destinationInventory, input.pack, input.to, 'destination');
+    if (!hasScopedPackPlacementEvidence(input.sourceInventory)) {
+        throw new Error(`Pack ${input.pack} is not installed at ${input.from} scope`);
+    }
+    const conflicts = input.destinationInventory.assets.filter(({ definition: asset, status }) => asset.ownership[input.to] === 'managed' && status === 'newer');
+    const unfilteredDestinationPlan = planPackReconcile({
+        pack: input.pack,
+        scope: input.to,
+        scopeRoot: input.destinationRoot,
+        assetsRoot: input.assetsRoot,
+        action: 'migrate-destination',
+        inventory: input.destinationInventory,
+    });
+    const conflictIds = new Set(conflicts.map(({ definition: asset }) => asset.id));
+    const conflictCanonicalPaths = new Set(conflicts.flatMap(({ definition: asset }) => asset.kind === 'skill' || asset.kind === 'agent'
+        ? [asset.destination]
+        : []));
+    const destinationPlan = {
+        ...unfilteredDestinationPlan,
+        operations: unfilteredDestinationPlan.operations.filter((operation) => operation.kind === 'write-intent' ||
+            !conflictIds.has(operation.assetId)),
+        changedCanonicalPaths: unfilteredDestinationPlan.changedCanonicalPaths.filter((path) => !conflictCanonicalPaths.has(path)),
+    };
+    const additionIds = new Set(destinationPlan.operations.flatMap((operation) => operation.kind === 'write-intent' ? [] : [operation.assetId]));
+    const additions = input.destinationInventory.assets
+        .filter(({ definition }) => additionIds.has(definition.id) && !conflictIds.has(definition.id))
+        .map((asset) => previewAsset(asset, input.to, 'destination-reconcile'));
+    const duplicates = input.destinationInventory.assets
+        .filter(({ definition: asset, status }) => asset.ownership[input.to] === 'managed' && status === 'current')
+        .map((asset) => previewAsset(asset, input.to, 'already-current'));
+    const retainedIds = new Set((input.sourceRetentions ?? []).map(({ assetId }) => assetId));
+    const removals = input.sourceInventory.assets
+        .filter(({ definition: asset, status }) => asset.ownership[input.from] === 'managed' &&
+        status !== 'missing' &&
+        !retainedIds.has(asset.id))
+        .map((asset) => previewAsset(asset, input.from, 'source-managed'));
+    const retained = input.sourceInventory.assets
+        .filter(({ definition: asset, status }) => asset.ownership[input.from] === 'seed-if-missing' &&
+        status !== 'missing')
+        .map((asset) => previewAsset(asset, input.from, 'scope-owner-data'))
+        .concat(input.destinationInventory.assets
+        .filter(({ definition: asset, status }) => asset.ownership[input.to] === 'seed-if-missing' &&
+        status !== 'missing')
+        .map((asset) => previewAsset(asset, input.to, 'scope-owner-data')))
+        .concat((input.sourceRetentions ?? []).flatMap((retention) => {
+        const asset = input.sourceInventory.assets.find(({ definition }) => definition.id === retention.assetId);
+        return asset
+            ? [
+                previewAsset(asset, input.from, `shared owner: ${retention.retainedBy.join(', ')}`),
+            ]
+            : [];
+    }))
+        .filter((entry, index, entries) => entries.findIndex((candidate) => candidate.assetId === entry.assetId &&
+        candidate.path === entry.path) === index);
+    return {
+        pack: input.pack,
+        from: input.from,
+        to: input.to,
+        projectRoot: input.from === 'project' ? input.sourceRoot : input.destinationRoot,
+        sourceIntent: input.sourceInventory.intent.source,
+        status: conflicts.length > 0 ? 'blocked' : 'ready',
+        additions,
+        duplicates,
+        conflicts: conflicts.map((asset) => previewAsset(asset, input.to, 'newer-destination-asset')),
+        removals,
+        retained,
+        diagnostics: input.destinationInventory.intent.diagnostics,
+        destinationPlan,
+    };
+}
+export async function executeMigrationDestination(preview, destinationRoot, dependencies) {
+    if (preview.destinationPlan.pack !== preview.pack ||
+        preview.destinationPlan.scope !== preview.to ||
+        preview.destinationPlan.action !== 'migrate-destination') {
+        throw new Error('Migration destination plan does not match the preview');
+    }
+    if (preview.status === 'blocked' || preview.conflicts.length > 0) {
+        throw new Error(`Migration destination conflicts must be resolved before mutation: ${preview.conflicts.map(({ assetId }) => assetId).join(', ')}`);
+    }
+    const applied = await (dependencies.apply ?? applyPackReconcilePlan)(preview.destinationPlan, destinationRoot, { ...dependencies.applyDependencies, sync: undefined });
+    const destinationInventory = applied.inventory;
+    const drifted = destinationInventory.assets.filter(({ definition: asset, status }) => asset.ownership[preview.to] === 'managed' && status !== 'current');
+    if (destinationInventory.pack !== preview.pack ||
+        destinationInventory.scope !== preview.to ||
+        destinationInventory.completeness !== 'complete' ||
+        !destinationInventory.intent.enabled ||
+        destinationInventory.intent.source !== 'declared' ||
+        drifted.length > 0) {
+        throw new Error(`Migration destination verification did not produce a complete current declared installation for ${preview.pack} at ${preview.to} scope`);
+    }
+    const canonicalPaths = getPackDefinition(preview.pack)
+        .assets.filter(({ kind, scopes }) => scopes.includes(preview.to) && (kind === 'skill' || kind === 'agent'))
+        .map(({ destination }) => destination);
+    try {
+        await dependencies.sync?.({
+            scope: preview.to,
+            action: 'install',
+            canonicalPaths,
+        });
+    }
+    catch (error) {
+        const pendingSync = pendingSyncState(preview, preview.to, 'install', canonicalPaths);
+        return {
+            preview,
+            status: 'destination-sync-failed',
+            destinationInventory,
+            pendingSync,
+            recovery: [
+                `Destination provider sync failed: ${error instanceof Error ? error.message : String(error)}`,
+                `Source was retained. Retry provider sync: ${pendingSync.command}`,
+                migrationRetry(preview),
+            ],
+        };
+    }
+    return {
+        preview,
+        status: 'destination-verified',
+        destinationInventory,
+    };
+}
+function migrationRetry(preview) {
+    return `Re-run interactively: ${renderCommand([
+        'oat',
+        '--cwd',
+        preview.projectRoot,
+        'tools',
+        'migrate',
+        '--pack',
+        preview.pack,
+        '--from',
+        preview.from,
+        '--to',
+        preview.to,
+    ])}`;
+}
+function pendingSyncState(preview, scope, action, canonicalPaths) {
+    const flag = action === 'install' ? '--install-canonical' : '--remove-canonical';
+    return {
+        scope,
+        action,
+        projectRoot: preview.projectRoot,
+        canonicalPaths,
+        command: renderCommand([
+            'oat',
+            '--cwd',
+            preview.projectRoot,
+            'sync',
+            '--scope',
+            scope,
+            ...canonicalPaths.flatMap((path) => [flag, path]),
+        ]),
+    };
+}
+function quoteCommandArgument(argument) {
+    if (/^[a-zA-Z0-9_@+=:,./-]+$/.test(argument))
+        return argument;
+    return process.platform === 'win32'
+        ? `'${argument.replaceAll("'", "''")}'`
+        : `'${argument.replaceAll("'", `'"'"'`)}'`;
+}
+function renderCommand(arguments_) {
+    return arguments_.map(quoteCommandArgument).join(' ');
+}
+export async function completeMigrationSourceRemoval(destination, input, dependencies) {
+    if (destination.status !== 'destination-verified' &&
+        destination.status !== 'source-removal-failed' &&
+        destination.status !== 'source-sync-failed') {
+        throw new Error('Migration source removal requires a verified destination outcome');
+    }
+    if (!destination.destinationInventory) {
+        throw new Error('Migration source removal requires verified destination inventory');
+    }
+    const preview = destination.preview;
+    if (destination.status === 'source-sync-failed') {
+        if (!destination.pendingSync ||
+            destination.pendingSync.action !== 'remove') {
+            throw new Error('Source sync retry is missing its canonical path state');
+        }
+        try {
+            await dependencies.sync?.({
+                scope: destination.pendingSync.scope,
+                action: 'remove',
+                canonicalPaths: destination.pendingSync.canonicalPaths,
+            });
+            return {
+                ...destination,
+                status: 'migrated',
+                pendingSync: undefined,
+                recovery: undefined,
+            };
+        }
+        catch (error) {
+            return {
+                ...destination,
+                recovery: [
+                    `Source provider sync failed: ${error instanceof Error ? error.message : String(error)}`,
+                    `Retry provider sync: ${destination.pendingSync.command}`,
+                ],
+            };
+        }
+    }
+    if (input.confirmation !== 'confirmed') {
+        return {
+            ...destination,
+            status: 'retained-both',
+            recovery: [
+                input.confirmation === 'non-interactive'
+                    ? 'Source removal requires interactive confirmation; both scopes were retained.'
+                    : 'Source removal was declined; both scopes were retained.',
+                migrationRetry(preview),
+            ],
+        };
+    }
+    const sourceBefore = await dependencies.inventory();
+    assertInventory(sourceBefore, preview.pack, preview.from, 'source');
+    const sourceRetentions = (await dependencies.resolveSourceRetentions?.()) ?? [];
+    const sourcePlan = (dependencies.plan ?? planPackReconcile)({
+        pack: preview.pack,
+        scope: preview.from,
+        scopeRoot: input.sourceRoot,
+        assetsRoot: input.assetsRoot,
+        action: 'remove',
+        inventory: sourceBefore,
+        retainedAssets: sourceRetentions,
+    });
+    try {
+        const applied = await (dependencies.apply ?? applyPackReconcilePlan)(sourcePlan, input.sourceRoot, {
+            ...dependencies.applyDependencies,
+            inventory: dependencies.inventory,
+            sync: undefined,
+        });
+        try {
+            await dependencies.sync?.({
+                scope: preview.from,
+                action: 'remove',
+                canonicalPaths: sourcePlan.changedCanonicalPaths,
+            });
+        }
+        catch (error) {
+            const pendingSync = pendingSyncState(preview, preview.from, 'remove', sourcePlan.changedCanonicalPaths);
+            return {
+                preview,
+                status: 'source-sync-failed',
+                destinationInventory: destination.destinationInventory,
+                sourceInventory: applied.inventory,
+                pendingSync,
+                recovery: [
+                    `Source provider sync failed: ${error instanceof Error ? error.message : String(error)}`,
+                    `Retry provider sync: ${pendingSync.command}`,
+                ],
+            };
+        }
+        return {
+            preview,
+            status: 'migrated',
+            destinationInventory: destination.destinationInventory,
+            sourceInventory: applied.inventory,
+        };
+    }
+    catch (error) {
+        let sourceInventory = sourceBefore;
+        let inventoryFailure = null;
+        try {
+            sourceInventory = await dependencies.inventory();
+        }
+        catch (inventoryError) {
+            inventoryFailure =
+                inventoryError instanceof Error
+                    ? inventoryError.message
+                    : String(inventoryError);
+        }
+        const remaining = sourceInventory.assets
+            .filter(({ definition: asset, status }) => asset.ownership[preview.from] === 'managed' &&
+            status !== 'missing' &&
+            !sourceRetentions.some(({ assetId }) => assetId === asset.id))
+            .map(({ path }) => path);
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            preview,
+            status: 'source-removal-failed',
+            destinationInventory: destination.destinationInventory,
+            sourceInventory,
+            recovery: [
+                `Source removal failed: ${detail}`,
+                `Remaining source paths: ${remaining.length > 0 ? remaining.join(', ') : 'inventory unavailable'}`,
+                ...(inventoryFailure
+                    ? [`Source re-inventory failed: ${inventoryFailure}`]
+                    : []),
+                migrationRetry(preview),
+            ],
+        };
+    }
+}

package/dist/commands/tools/outdated/outdated-tools.d.ts

@@ -1,13 +1,24 @@
 import type { CommandContext } from '../../../app/command-context.js';
+import { type InventoryScopedPackInput, type ScopedPackInventory } from '../../tools/shared/pack-inventory.js';
 import type { ScanToolsOptions } from '../../tools/shared/scan-tools.js';
 import type { ToolInfo } from '../../tools/shared/types.js';
 export interface OutdatedToolsDependencies {
     scanTools: (options: ScanToolsOptions) => Promise<ToolInfo[]>;
     resolveScopeRoot: (scope: 'project' | 'user', cwd: string, home: string) => Promise<string>;
     resolveAssetsRoot: () => Promise<string>;
+    inventoryScopedPack?: (input: InventoryScopedPackInput) => Promise<ScopedPackInventory>;
+}
+export interface RepairablePack {
+    pack: ScopedPackInventory['pack'];
+    scope: ScopedPackInventory['scope'];
+    completeness: ScopedPackInventory['completeness'];
+    missing: string[];
+    drifted: string[];
+    intended: boolean;
 }
 export interface OutdatedToolsResult {
     tools: ToolInfo[];
+    packs: RepairablePack[];
 }
 export declare function runOutdatedTools(context: CommandContext, dependencies: OutdatedToolsDependencies): Promise<OutdatedToolsResult>;
 //# sourceMappingURL=outdated-tools.d.ts.map

package/dist/commands/tools/outdated/outdated-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outdated-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/outdated/outdated-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,gBAAgB,EAAE,CAChB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,yBAAyB,GACtC,OAAO,CAAC,mBAAmB,CAAC,CAiE9B"}
+{"version":3,"file":"outdated-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/outdated/outdated-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACzB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,gBAAgB,EAAE,CAChB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,mBAAmB,CAAC,EAAE,CACpB,KAAK,EAAE,wBAAwB,KAC5B,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAClC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACpC,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,CAAC;IAClD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,yBAAyB,GACtC,OAAO,CAAC,mBAAmB,CAAC,CAoG9B"}

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

@@ -1,9 +1,12 @@
 import { resolveConcreteScopes } from '../../shared/shared.utils.js';
+import { inventoryScopedPack, } from '../../tools/shared/pack-inventory.js';
+import { PACK_MANIFEST } from '../../tools/shared/pack-manifest.js';
 export async function runOutdatedTools(context, dependencies) {
     const { logger } = context;
     const scopes = resolveConcreteScopes(context.scope);
     const assetsRoot = await dependencies.resolveAssetsRoot();
     const outdated = [];
+    const packs = [];
     for (const scope of scopes) {
         const scopeRoot = await dependencies.resolveScopeRoot(scope, context.cwd, context.home);
         const tools = await dependencies.scanTools({
@@ -12,14 +15,36 @@ export async function runOutdatedTools(context, dependencies) {
             assetsRoot,
         });
         outdated.push(...tools.filter((t) => t.status === 'outdated'));
+        for (const { name: pack, allowedScopes } of PACK_MANIFEST) {
+            if (!allowedScopes.includes(scope))
+                continue;
+            const inventory = await (dependencies.inventoryScopedPack ?? inventoryScopedPack)({ pack, scope, scopeRoot, assetsRoot });
+            const missing = inventory.assets
+                .filter(({ definition, status }) => definition.ownership[scope] === 'managed' && status === 'missing')
+                .map(({ definition }) => definition.id);
+            const drifted = inventory.assets
+                .filter(({ status }) => status === 'outdated' || status === 'newer')
+                .map(({ definition }) => definition.id);
+            if (drifted.length > 0 ||
+                (inventory.intent.enabled && inventory.completeness !== 'complete')) {
+                packs.push({
+                    pack,
+                    scope,
+                    completeness: inventory.completeness,
+                    missing,
+                    drifted,
+                    intended: inventory.intent.enabled,
+                });
+            }
+        }
     }
     if (context.json) {
-        logger.json({ tools: outdated });
-        return { tools: outdated };
+        logger.json({ tools: outdated, packs });
+        return { tools: outdated, packs };
     }
-    if (outdated.length === 0) {
+    if (outdated.length === 0 && packs.length === 0) {
         logger.info('All tools are up to date.');
-        return { tools: outdated };
+        return { tools: outdated, packs };
     }
     logger.info('Outdated tools:\n');
     const header = formatRow('NAME', 'TYPE', 'INSTALLED', 'AVAILABLE', 'PACK', 'SCOPE');
@@ -29,7 +54,10 @@ export async function runOutdatedTools(context, dependencies) {
     for (const tool of outdated) {
         logger.info(formatRow(tool.name, tool.type, tool.version ?? '-', tool.bundledVersion ?? '-', tool.pack, tool.scope));
     }
-    return { tools: outdated };
+    for (const pack of packs) {
+        logger.info(`Pack ${pack.pack}@${pack.scope} is repairable (${pack.completeness}; missing=${pack.missing.length}; drifted=${pack.drifted.length}).`);
+    }
+    return { tools: outdated, packs };
 }
 function formatRow(name, type, installed, available, pack, scope) {
     return [

package/dist/commands/tools/remove/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAO1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,uBAAuB,EAE7B,MAAM,gBAAgB,CAAC;AA4CxB,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAuFT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/index.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAS1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,uBAAuB,EAE7B,MAAM,gBAAgB,CAAC;AAmExB,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAiHT"}

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

@@ -1,12 +1,12 @@
 import { execFile } from 'node:child_process';
-import { rm } from 'node:fs/promises';
+import { lstat, rm } from 'node:fs/promises';
+import { relative } from 'node:path';
 import { buildCommandContext } from '../../../app/command-context.js';
 import { withScopeOption } from '../../shared/scope-option.js';
 import { readGlobalOptions, resolveConcreteScopes, } from '../../shared/shared.utils.js';
 import { autoSync, } from '../../tools/shared/auto-sync.js';
-import { reconcileProjectToolsConfig } from '../../tools/shared/project-tools-config.js';
 import { scanTools } from '../../tools/shared/scan-tools.js';
-import { readOatConfig, writeOatConfig } from '../../../config/oat-config.js';
+import { hasScopedPackOwnershipEvidence, writeScopedPackIntent, } from '../../tools/shared/scoped-pack-intent.js';
 import { resolveAssetsRoot } from '../../../fs/assets.js';
 import { resolveProjectRoot, resolveScopeRoot } from '../../../fs/paths.js';
 import { Command } from 'commander';
@@ -25,11 +25,37 @@ const defaultDependencies = {
     removeFile: async (path) => {
         await rm(path, { force: true });
     },
+    pathExists: async (path) => {
+        try {
+            await lstat(path);
+            return true;
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return false;
+            }
+            throw error;
+        }
+    },
+    hasPackOwnershipEvidence: async (pack, scope, scopeRoot) => hasScopedPackOwnershipEvidence({ pack, scope, scopeRoot }),
 };
 const defaultSyncDependencies = {
-    runSync: async ({ scope, cwd }) => {
+    runSync: async ({ scope, cwd, removedCanonicalPaths }) => {
+        const args = [
+            ...process.execArgv,
+            process.argv[1],
+            'sync',
+            '--scope',
+            scope,
+        ];
+        for (const canonicalPath of removedCanonicalPaths ?? []) {
+            args.push('--remove-canonical', canonicalPath);
+        }
         await new Promise((resolve, reject) => {
-            execFile(process.execPath, [...process.execArgv, process.argv[1], 'sync', '--scope', scope], { cwd }, (error) => {
+            execFile(process.execPath, args, { cwd }, (error) => {
                 if (error)
                     reject(error);
                 else
@@ -69,18 +95,28 @@ export function createToolsRemoveCommand(dependencies = defaultDependencies, syn
         const scopes = resolveConcreteScopes(context.scope);
         const dryRun = opts.dryRun ?? false;
         const result = await removeTools(target, scopes, context.cwd, context.home, dryRun, dependencies);
-        if (!dryRun && result.removed.length > 0) {
-            const repoRoot = await resolveProjectRoot(context.cwd);
-            await reconcileProjectToolsConfig({
-                repoRoot,
-                cwd: context.cwd,
-                home: context.home,
-            }, {
-                resolveAssetsRoot: dependencies.resolveAssetsRoot,
-                scanTools: dependencies.scanTools,
-                readOatConfig,
-                writeOatConfig,
-            });
+        if (!dryRun && target.kind !== 'name') {
+            const packs = target.kind === 'pack' ? [target.pack] : [...VALID_PACKS];
+            for (const scope of scopes) {
+                const scopeRoot = await dependencies.resolveScopeRoot(scope, context.cwd, context.home);
+                for (const pack of packs) {
+                    // Durable scoped intent is what lets `oat tools update` restore a
+                    // pack whose files are all missing, so it may only be cleared for a
+                    // pack this run actually removed something for. A removal that
+                    // removed nothing reports nothing and must leave intent alone.
+                    const removedForPack = result.packOutcomes.some((outcome) => outcome.pack === pack &&
+                        outcome.scope === scope &&
+                        outcome.removed);
+                    if (!removedForPack)
+                        continue;
+                    await writeScopedPackIntent({
+                        pack,
+                        scope,
+                        scopeRoot,
+                        enabled: false,
+                    });
+                }
+            }
         }
         if (result.notInstalled.length > 0) {
             if (context.json) {
@@ -93,9 +129,14 @@ export function createToolsRemoveCommand(dependencies = defaultDependencies, syn
             return;
         }
         // Auto-sync after mutations (before output so sync errors are captured)
-        if (result.removed.length > 0 && !dryRun && opts.sync !== false) {
-            const affectedScopes = [...new Set(result.removed.map((t) => t.scope))];
-            await autoSync(affectedScopes, context.cwd, context.home, logger, syncDependencies);
+        if (!dryRun && opts.sync !== false) {
+            for (const scope of scopes) {
+                const scopeRoot = await dependencies.resolveScopeRoot(scope, context.cwd, context.home);
+                const removedCanonicalPaths = canonicalRemovalPaths(result, scope, scopeRoot);
+                if (removedCanonicalPaths.length === 0)
+                    continue;
+                await autoSync([scope], context.cwd, context.home, logger, syncDependencies, { removedCanonicalPaths });
+            }
         }
         if (context.json) {
             logger.json({ target: describeTarget(target), dryRun, result });
@@ -112,6 +153,18 @@ export function createToolsRemoveCommand(dependencies = defaultDependencies, syn
         }
     });
 }
+function canonicalRemovalPaths(result, scope, scopeRoot) {
+    const paths = result.removedAssets
+        .filter((asset) => asset.scope === scope)
+        .map((asset) => relative(scopeRoot, asset.path).replaceAll('\\', '/'))
+        .filter((path) => /^\.agents\/(?:skills\/[^/]+|agents\/[^/]+\.md)$/.test(path));
+    paths.push(...result.removed
+        .filter((tool) => tool.scope === scope)
+        .map((tool) => tool.type === 'skill'
+        ? `.agents/skills/${tool.name}`
+        : `.agents/agents/${tool.name}.md`));
+    return [...new Set(paths)];
+}
 function resolveTarget(name, pack, all) {
     const specified = [name, pack, all].filter(Boolean).length;
     if (specified !== 1)

package/dist/commands/tools/remove/remove-tools.d.ts

@@ -16,14 +16,42 @@ export interface RemoveToolsDependencies {
     resolveAssetsRoot: () => Promise<string>;
     removeDirectory: (path: string) => Promise<void>;
     removeFile: (path: string) => Promise<void>;
+    pathExists: (path: string) => Promise<boolean>;
+    hasPackOwnershipEvidence: (pack: PackName, scope: ConcreteScope, scopeRoot: string) => Promise<boolean>;
 }
 interface RemovedTool {
     name: string;
     type: 'skill' | 'agent';
     scope: ConcreteScope;
 }
+/**
+ * Per-pack, per-scope evidence that a removal actually acted on the pack.
+ *
+ * `removed` is true when a scanned pack tool matched, or when a
+ * manifest-declared managed destination for that pack existed on disk before
+ * removal ran (including one retained for a shared owner). It gates clearing
+ * durable scoped intent: a removal that found no trace of a pack removed
+ * nothing, reports that nothing was removed, and must leave the intent that
+ * `oat tools update` restores from (FR5) untouched. Under `--dry-run` it
+ * reports what a real run would have acted on.
+ */
+export interface PackRemovalOutcome {
+    pack: PackName;
+    scope: ConcreteScope;
+    removed: boolean;
+}
 export interface RemoveResult {
     removed: RemovedTool[];
+    removedAssets: Array<{
+        path: string;
+        scope: ConcreteScope;
+    }>;
+    retainedOwnerData: Array<{
+        path: string;
+        scope: ConcreteScope;
+        reason: string;
+    }>;
+    packOutcomes: PackRemovalOutcome[];
     notInstalled: string[];
 }
 export declare function removeTools(target: RemoveTarget, scopes: ConcreteScope[], cwd: string, home: string, dryRun: boolean, deps: RemoveToolsDependencies): Promise<RemoveResult>;

package/dist/commands/tools/remove/remove-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/remove-tools.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,gBAAgB,EAAE,CAChB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7C;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,KAAK,EAAE,aAAa,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAqDD,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAgCvB"}
+{"version":3,"file":"remove-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/remove-tools.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAEV,QAAQ,EACR,QAAQ,EACT,MAAM,8BAA8B,CAAC;AAMtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,gBAAgB,EAAE,CAChB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,wBAAwB,EAAE,CACxB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;IAC7D,iBAAiB,EAAE,KAAK,CAAC;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,aAAa,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IACH,YAAY,EAAE,kBAAkB,EAAE,CAAC;IACnC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AA8MD,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAsGvB"}