@open-agent-toolkit/cli 0.2.35 → 0.2.37

package/dist/commands/tools/shared/pack-manifest.js

@@ -0,0 +1,384 @@
+import { isAbsolute, posix } from 'node:path';
+export const PACK_NAMES = [
+    'core',
+    'ideas',
+    'docs',
+    'workflows',
+    'utility',
+    'project-management',
+    'research',
+    'brainstorm',
+];
+export function isPackName(value) {
+    return PACK_NAMES.includes(value);
+}
+const BOTH_SCOPES = ['project', 'user'];
+const BOTH_MANAGED = { project: 'managed', user: 'managed' };
+const TEMPLATE_OWNERSHIP = {
+    project: 'seed-if-missing',
+    user: 'managed',
+};
+function skill(name, scopes = BOTH_SCOPES) {
+    return {
+        id: `skill:${name}`,
+        kind: 'skill',
+        source: `skills/${name}`,
+        destination: `.agents/skills/${name}`,
+        scopes,
+        ownership: scopes.length === 1 ? { user: 'managed' } : BOTH_MANAGED,
+    };
+}
+function agent(name) {
+    return {
+        id: `agent:${name}`,
+        kind: 'agent',
+        source: `agents/${name}`,
+        destination: `.agents/agents/${name}`,
+        scopes: BOTH_SCOPES,
+        ownership: BOTH_MANAGED,
+    };
+}
+function template(name, kind = 'template') {
+    return {
+        id: `template:${name}`,
+        kind,
+        source: `templates/${name}`,
+        destination: `.oat/templates/${name}`,
+        scopes: BOTH_SCOPES,
+        ownership: TEMPLATE_OWNERSHIP,
+    };
+}
+function script(name, sharedOwner) {
+    return {
+        id: `script:${name}`,
+        kind: 'script',
+        source: `scripts/${name}`,
+        destination: `.oat/scripts/${name}`,
+        scopes: BOTH_SCOPES,
+        ownership: BOTH_MANAGED,
+        executable: true,
+        sharedOwner,
+    };
+}
+function seed(id, destination, options) {
+    const scopes = options.scopes ?? BOTH_SCOPES;
+    return {
+        id: `seed:${id}`,
+        kind: 'seed',
+        source: options.source,
+        generation: options.generation,
+        destination,
+        scopes,
+        ownership: Object.fromEntries(scopes.map((scope) => [scope, 'seed-if-missing'])),
+    };
+}
+const WORKFLOW_SKILL_NAMES = [
+    'oat-cursor-cloud-projects',
+    'oat-explainer-kit',
+    'oat-project-autonomous',
+    'oat-project-capture',
+    'oat-project-clear-active',
+    'oat-project-complete',
+    'oat-project-design',
+    'oat-project-dispatch-subagents',
+    'oat-project-discover',
+    'oat-project-document',
+    'oat-project-implement',
+    'oat-project-import-plan',
+    'oat-project-new',
+    'oat-project-next',
+    'oat-project-open',
+    'oat-project-plan',
+    'oat-project-plan-writing',
+    'oat-project-pr-final',
+    'oat-project-pr-progress',
+    'oat-project-progress',
+    'oat-project-promote-spec-driven',
+    'oat-project-quick-start',
+    'oat-project-reconcile',
+    'oat-project-retro',
+    'oat-project-retro-file',
+    'oat-project-revise',
+    'oat-project-review-provide',
+    'oat-project-review-provide-remote',
+    'oat-project-review-receive',
+    'oat-project-review-receive-remote',
+    'oat-project-spec',
+    'oat-project-split',
+    'oat-project-summary',
+    'oat-repo-knowledge-index',
+    'oat-worktree-bootstrap',
+    'oat-worktree-bootstrap-auto',
+    'oat-wave-execute',
+    'oat-wave-program',
+    'oat-wrap-up',
+];
+export const PACK_MANIFEST = [
+    {
+        name: 'core',
+        allowedScopes: ['user'],
+        defaultScope: 'user',
+        assets: [
+            skill('oat-docs', ['user']),
+            skill('oat-doctor', ['user']),
+            {
+                id: 'directory:docs',
+                kind: 'directory',
+                source: 'docs',
+                destination: '.oat/docs',
+                scopes: ['user'],
+                ownership: { user: 'managed' },
+            },
+        ],
+    },
+    {
+        name: 'ideas',
+        allowedScopes: BOTH_SCOPES,
+        defaultScope: 'user',
+        assets: [
+            ...[
+                'oat-idea-new',
+                'oat-idea-ideate',
+                'oat-idea-summarize',
+                'oat-idea-scratchpad',
+            ].map((name) => skill(name)),
+            seed('ideas-backlog', '.oat/ideas/backlog.md', {
+                source: 'templates/ideas/ideas-backlog.md',
+            }),
+            seed('ideas-scratchpad', '.oat/ideas/scratchpad.md', {
+                source: 'templates/ideas/ideas-scratchpad.md',
+            }),
+            template('ideas/idea-discovery.md'),
+            template('ideas/idea-summary.md'),
+        ],
+    },
+    {
+        name: 'docs',
+        allowedScopes: BOTH_SCOPES,
+        defaultScope: 'user',
+        assets: [
+            ...[
+                'authoring-docs',
+                'oat-agent-instructions-analyze',
+                'oat-agent-instructions-apply',
+                'oat-docs-analyze',
+                'oat-docs-apply',
+                'oat-docs-authoring',
+                'oat-docs-bootstrap',
+            ].map((name) => skill(name)),
+            template('docs-app-mkdocs', 'directory'),
+            template('docs-app-fuma', 'directory'),
+            script('resolve-tracking.sh', 'resolve-tracking'),
+        ],
+    },
+    {
+        name: 'workflows',
+        allowedScopes: BOTH_SCOPES,
+        defaultScope: 'user',
+        assets: [
+            ...WORKFLOW_SKILL_NAMES.map((name) => skill(name)),
+            ...[
+                'oat-codebase-mapper.md',
+                'oat-phase-implementer.md',
+                'oat-reviewer.md',
+            ].map((name) => agent(name)),
+            ...[
+                'state.md',
+                'discovery.md',
+                'spec.md',
+                'design.md',
+                'plan.md',
+                'implementation.md',
+                'summary.md',
+                'project-log.md',
+                'project-retro.md',
+            ].map((name) => template(name)),
+            ...[
+                'generate-oat-state.sh',
+                'generate-thin-index.sh',
+                'resolve-tracking.sh',
+            ].map((name) => script(name, name === 'resolve-tracking.sh' ? 'resolve-tracking' : undefined)),
+            seed('projects-root', '.oat/projects-root', {
+                generation: 'projects-root-default',
+                scopes: ['project'],
+            }),
+            seed('projects-config', '.oat/config.json', {
+                generation: 'projects-config-default',
+                scopes: ['project'],
+            }),
+            seed('projects-local-gitkeep', '.oat/projects/local/.gitkeep', {
+                generation: 'empty-file',
+                scopes: ['project'],
+            }),
+            seed('projects-archived-gitkeep', '.oat/projects/archived/.gitkeep', {
+                generation: 'empty-file',
+                scopes: ['project'],
+            }),
+        ],
+    },
+    {
+        name: 'utility',
+        allowedScopes: BOTH_SCOPES,
+        defaultScope: 'user',
+        assets: [
+            ...[
+                'create-agnostic-skill',
+                'explainer-kit',
+                'oat-dispatch-subagents',
+                'subagent-orchestration',
+                'oat-repo-improve',
+                'oat-repo-maintainability-review',
+                'oat-review-provide',
+                'oat-review-provide-remote',
+                'oat-review-receive',
+                'oat-review-receive-remote',
+            ].map((name) => skill(name)),
+        ],
+    },
+    {
+        name: 'project-management',
+        allowedScopes: BOTH_SCOPES,
+        defaultScope: 'user',
+        assets: [
+            ...[
+                'oat-pjm-add-backlog-item',
+                'oat-pjm-decision',
+                'oat-pjm-update-repo-reference',
+                'oat-pjm-review-backlog',
+            ].map((name) => skill(name)),
+            ...[
+                'backlog-item.md',
+                'roadmap.md',
+                'current-state.md',
+                'decision.md',
+                'repo-agents.md',
+                'pjm-agents.md',
+                'reference-agents.md',
+                'repo-readme.md',
+                'pjm-handoffs-readme.md',
+            ].map((name) => template(name)),
+        ],
+    },
+    {
+        name: 'research',
+        allowedScopes: BOTH_SCOPES,
+        defaultScope: 'user',
+        assets: [
+            ...['analyze', 'compare', 'deep-research', 'skeptic', 'synthesize'].map((name) => skill(name)),
+            agent('skeptical-evaluator.md'),
+        ],
+    },
+    {
+        name: 'brainstorm',
+        allowedScopes: BOTH_SCOPES,
+        defaultScope: 'user',
+        assets: [skill('oat-brainstorm')],
+    },
+];
+export function getPackDefinition(pack) {
+    const definition = PACK_MANIFEST.find(({ name }) => name === pack);
+    if (!definition) {
+        throw new Error(`Unknown pack: ${pack}`);
+    }
+    return definition;
+}
+export function getPackAssets(pack, kind) {
+    const assets = getPackDefinition(pack).assets;
+    return kind ? assets.filter((asset) => asset.kind === kind) : assets;
+}
+export function getPackMemberNames(pack, kind) {
+    return getPackAssets(pack, kind).map(({ source }) => {
+        if (!source) {
+            throw new Error(`Pack ${pack} ${kind} asset has no materialized source`);
+        }
+        const prefix = `${kind === 'template' ? 'templates' : `${kind}s`}/`;
+        return source.slice(prefix.length);
+    });
+}
+export function getCanonicalProviderPaths(pack) {
+    return getPackDefinition(pack)
+        .assets.filter(({ kind }) => kind === 'skill' || kind === 'agent')
+        .map(({ destination }) => destination);
+}
+function validateRelativePath(pack, asset, field) {
+    const value = asset[field];
+    if (value === undefined)
+        return;
+    const segments = value.replaceAll('\\', '/').split('/');
+    if (value.length === 0 ||
+        isAbsolute(value) ||
+        /^[A-Za-z]:[\\/]/.test(value) ||
+        segments.includes('..') ||
+        posix.normalize(value).startsWith('../')) {
+        throw new Error(`Pack ${pack} asset ${asset.id} ${field} must be relative to its scope and contain no parent traversal: ${value}`);
+    }
+}
+function validateAsset(pack, asset) {
+    if ((asset.source === undefined) === (asset.generation === undefined)) {
+        throw new Error(`Pack ${pack.name} asset ${asset.id} must declare exactly one source or generation contract`);
+    }
+    validateRelativePath(pack.name, asset, 'source');
+    validateRelativePath(pack.name, asset, 'destination');
+    if (asset.scopes.length === 0) {
+        throw new Error(`Pack ${pack.name} asset ${asset.id} has no scopes`);
+    }
+    for (const scope of asset.scopes) {
+        if (!pack.allowedScopes.includes(scope)) {
+            throw new Error(`Pack ${pack.name} asset ${asset.id} uses disallowed scope ${scope}`);
+        }
+        if (!asset.ownership[scope]) {
+            throw new Error(`Pack ${pack.name} asset ${asset.id} has no ownership for ${scope}`);
+        }
+    }
+    for (const scope of Object.keys(asset.ownership)) {
+        if (!asset.scopes.includes(scope)) {
+            throw new Error(`Pack ${pack.name} asset ${asset.id} declares ownership outside scope ${scope}`);
+        }
+    }
+}
+export function validatePackManifest(manifest = PACK_MANIFEST) {
+    const packNames = new Set();
+    const destinations = new Map();
+    for (const pack of manifest) {
+        if (packNames.has(pack.name)) {
+            throw new Error(`Duplicate pack name: ${pack.name}`);
+        }
+        packNames.add(pack.name);
+        if (!pack.allowedScopes.includes(pack.defaultScope)) {
+            throw new Error(`Pack ${pack.name} default scope ${pack.defaultScope} is not allowed`);
+        }
+        const assetIds = new Set();
+        for (const asset of pack.assets) {
+            if (assetIds.has(asset.id)) {
+                throw new Error(`Duplicate asset ID in pack ${pack.name}: ${asset.id}`);
+            }
+            assetIds.add(asset.id);
+            validateAsset(pack, asset);
+            for (const scope of asset.scopes) {
+                const key = `${scope}:${asset.destination}`;
+                const entries = destinations.get(key) ?? [];
+                entries.push({ pack: pack.name, asset });
+                destinations.set(key, entries);
+            }
+        }
+    }
+    for (const [destination, entries] of destinations) {
+        if (entries.length < 2)
+            continue;
+        const [first, ...rest] = entries;
+        const compatible = first.asset.sharedOwner !== undefined &&
+            rest.every(({ asset }) => asset.sharedOwner === first.asset.sharedOwner &&
+                asset.source === first.asset.source &&
+                asset.kind === first.asset.kind);
+        if (!compatible) {
+            throw new Error(`Pack assets collide at ${destination} without a compatible shared owner: ${entries.map(({ pack, asset }) => `${pack}/${asset.id}`).join(', ')}`);
+        }
+    }
+    if (manifest === PACK_MANIFEST) {
+        const missing = PACK_NAMES.filter((name) => !packNames.has(name));
+        if (missing.length > 0 || packNames.size !== PACK_NAMES.length) {
+            throw new Error(`Pack manifest must cover every PackName exactly once; missing: ${missing.join(', ') || 'none'}`);
+        }
+    }
+}
+validatePackManifest();

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

@@ -0,0 +1,21 @@
+import type { ConcreteScope } from '../../../shared/types.js';
+import type { PackName } from './types.js';
+/**
+ * Path presentation for managed pack diagnostics. `oat status` and `oat doctor`
+ * both render the same inventory model, and this is the code that implements
+ * the "diagnostics never echo unrelated home content" guarantee, so it lives in
+ * one place rather than being duplicated per command.
+ */
+export interface PackPathRoots {
+    projectRoot?: string;
+    userRoot?: string;
+}
+export declare const MAX_REPORTED_PACK_PATHS = 3;
+/**
+ * Renders a managed path relative to the scope root that owns it. User-scope
+ * paths collapse to `~/...` so diagnostics never echo unrelated home content.
+ */
+export declare function formatPackPath(path: string, roots: PackPathRoots): string;
+export declare function formatPackPaths(paths: string[], roots: PackPathRoots): string;
+export declare function updatePackRecovery(pack: PackName, scope: ConcreteScope): string;
+//# sourceMappingURL=pack-paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pack-paths.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-paths.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,CAgBzE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,CAQ7E;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,aAAa,GACnB,MAAM,CAER"}

package/dist/commands/tools/shared/pack-paths.js

@@ -0,0 +1,35 @@
+import { relative } from 'node:path';
+import { normalizeToPosixPath } from '../../../fs/paths.js';
+export const MAX_REPORTED_PACK_PATHS = 3;
+/**
+ * Renders a managed path relative to the scope root that owns it. User-scope
+ * paths collapse to `~/...` so diagnostics never echo unrelated home content.
+ */
+export function formatPackPath(path, roots) {
+    const normalized = normalizeToPosixPath(path);
+    for (const [root, prefix] of [
+        [roots.projectRoot, ''],
+        [roots.userRoot, '~/'],
+    ]) {
+        if (!root)
+            continue;
+        const normalizedRoot = normalizeToPosixPath(root);
+        if (normalized === normalizedRoot ||
+            normalized.startsWith(`${normalizedRoot}/`)) {
+            return `${prefix}${normalizeToPosixPath(relative(root, path))}`;
+        }
+    }
+    return normalized;
+}
+export function formatPackPaths(paths, roots) {
+    const shown = paths
+        .slice(0, MAX_REPORTED_PACK_PATHS)
+        .map((path) => formatPackPath(path, roots));
+    const remaining = paths.length - shown.length;
+    return remaining > 0
+        ? `${shown.join(', ')}, +${remaining} more`
+        : shown.join(', ');
+}
+export function updatePackRecovery(pack, scope) {
+    return `oat tools update --pack ${pack} --scope ${scope}`;
+}

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

@@ -0,0 +1,64 @@
+import type { ConcreteScope } from '../../../shared/types.js';
+import type { ScopedPackInventory } from './pack-inventory.js';
+import type { PackAssetGeneration, PackCompleteness, PackName } from './types.js';
+export type PackReconcileAction = 'install' | 'update' | 'remove' | 'migrate-destination';
+export type PackReconcileOperation = {
+    kind: 'copy-dir' | 'copy-file';
+    assetId: string;
+    source: string;
+    destination: string;
+    force: boolean;
+} | {
+    kind: 'write-generated';
+    assetId: string;
+    generation: PackAssetGeneration;
+    destination: string;
+} | {
+    kind: 'chmod';
+    assetId: string;
+    path: string;
+    mode: number;
+} | {
+    kind: 'remove-dir' | 'remove-file';
+    assetId: string;
+    path: string;
+} | {
+    kind: 'write-intent';
+    pack: PackName;
+    scope: ConcreteScope;
+    enabled: boolean;
+};
+export interface PackReconcilePlan {
+    pack: PackName;
+    scope: ConcreteScope;
+    action: PackReconcileAction;
+    operations: readonly PackReconcileOperation[];
+    expectedCompleteness: PackCompleteness;
+    changedCanonicalPaths: readonly string[];
+    retainedAssets: readonly PackSharedOwnerRetention[];
+}
+export interface PackSharedOwnerRetention {
+    assetId: string;
+    path: string;
+    retainedBy: readonly PackName[];
+    reason: 'retained-shared-owner';
+}
+export interface PlanPackReconcileInput {
+    pack: PackName;
+    scope: ConcreteScope;
+    scopeRoot: string;
+    assetsRoot: string;
+    action: PackReconcileAction;
+    inventory: ScopedPackInventory;
+    retainedAssets?: readonly PackSharedOwnerRetention[];
+}
+export interface ResolveSharedOwnerRetentionsInput {
+    packs: readonly PackName[];
+    scope: ConcreteScope;
+    scopeRoot: string;
+    hasOwnershipEvidence: (pack: PackName, scope: ConcreteScope, scopeRoot: string) => Promise<boolean>;
+}
+export declare function resolveSharedOwnerRetentions(input: ResolveSharedOwnerRetentionsInput): Promise<PackSharedOwnerRetention[]>;
+export declare function planPackReconcile(input: PlanPackReconcileInput): PackReconcilePlan;
+export declare function serializePackReconcilePlan(plan: PackReconcilePlan): string;
+//# sourceMappingURL=pack-reconcile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pack-reconcile.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-reconcile.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAEV,mBAAmB,EACnB,gBAAgB,EAChB,QAAQ,EACT,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,mBAAmB,GAC3B,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,qBAAqB,CAAC;AAE1B,MAAM,MAAM,sBAAsB,GAC9B;IACE,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;CAChB,GACD;IACE,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,mBAAmB,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9D;IAAE,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACrE;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEN,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC9C,oBAAoB,EAAE,gBAAgB,CAAC;IACvC,qBAAqB,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,cAAc,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACrD;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,QAAQ,EAAE,CAAC;IAChC,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,SAAS,EAAE,mBAAmB,CAAC;IAC/B,cAAc,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACtD;AAED,MAAM,WAAW,iCAAiC;IAChD,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC3B,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,CACpB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,iCAAiC,GACvC,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAmDrC;AA6ED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,sBAAsB,GAC5B,iBAAiB,CA4EnB;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAE1E"}

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

@@ -0,0 +1,158 @@
+import { join } from 'node:path';
+import { getPackDefinition, PACK_MANIFEST } from './pack-manifest.js';
+export async function resolveSharedOwnerRetentions(input) {
+    const selected = new Set(input.packs);
+    const retentions = [];
+    const seen = new Set();
+    for (const definition of PACK_MANIFEST.filter(({ name }) => selected.has(name))) {
+        for (const asset of definition.assets) {
+            if (!asset.sharedOwner ||
+                !asset.scopes.includes(input.scope) ||
+                asset.ownership[input.scope] !== 'managed' ||
+                seen.has(asset.destination)) {
+                continue;
+            }
+            const otherOwners = PACK_MANIFEST.filter(({ name, assets }) => !selected.has(name) &&
+                assets.some((candidate) => candidate.sharedOwner === asset.sharedOwner &&
+                    candidate.destination === asset.destination &&
+                    candidate.scopes.includes(input.scope) &&
+                    candidate.ownership[input.scope] === 'managed'));
+            const evidence = await Promise.all(otherOwners.map(async ({ name }) => ({
+                name,
+                retained: await input.hasOwnershipEvidence(name, input.scope, input.scopeRoot),
+            })));
+            const retainedBy = evidence
+                .filter(({ retained }) => retained)
+                .map(({ name }) => name);
+            if (retainedBy.length === 0)
+                continue;
+            seen.add(asset.destination);
+            retentions.push({
+                assetId: asset.id,
+                path: join(input.scopeRoot, asset.destination),
+                retainedBy,
+                reason: 'retained-shared-owner',
+            });
+        }
+    }
+    return retentions;
+}
+function isDirectoryAsset(asset) {
+    return asset.kind === 'skill' || asset.kind === 'directory';
+}
+function canonicalPath(asset) {
+    return asset.kind === 'skill' || asset.kind === 'agent'
+        ? asset.destination
+        : null;
+}
+function materializationOperations(asset, input) {
+    const observed = input.inventory.assets.find(({ definition }) => definition.id === asset.id);
+    const ownership = asset.ownership[input.scope];
+    const isMissing = observed?.status === 'missing';
+    if (ownership === 'seed-if-missing' && !isMissing)
+        return [];
+    if (ownership === 'managed' && observed?.status === 'current')
+        return [];
+    const destination = join(input.scopeRoot, asset.destination);
+    if (asset.generation) {
+        return [
+            {
+                kind: 'write-generated',
+                assetId: asset.id,
+                generation: asset.generation,
+                destination,
+            },
+        ];
+    }
+    if (!asset.source) {
+        throw new Error(`Pack asset ${asset.id} has no source or generation`);
+    }
+    const operations = [
+        {
+            kind: isDirectoryAsset(asset) ? 'copy-dir' : 'copy-file',
+            assetId: asset.id,
+            source: join(input.assetsRoot, asset.source),
+            destination,
+            force: ownership === 'managed',
+        },
+    ];
+    if (asset.executable) {
+        operations.push({
+            kind: 'chmod',
+            assetId: asset.id,
+            path: destination,
+            mode: 0o755,
+        });
+    }
+    return operations;
+}
+function removalOperation(asset, input) {
+    if (asset.ownership[input.scope] !== 'managed')
+        return null;
+    if (input.retainedAssets?.some(({ assetId }) => assetId === asset.id)) {
+        return null;
+    }
+    const observed = input.inventory.assets.find(({ definition }) => definition.id === asset.id);
+    if (!observed || observed.status === 'missing')
+        return null;
+    return {
+        kind: isDirectoryAsset(asset) ? 'remove-dir' : 'remove-file',
+        assetId: asset.id,
+        path: join(input.scopeRoot, asset.destination),
+    };
+}
+export function planPackReconcile(input) {
+    if (input.inventory.pack !== input.pack ||
+        input.inventory.scope !== input.scope) {
+        throw new Error('Pack reconcile inventory does not match requested pack and scope');
+    }
+    const packDefinition = getPackDefinition(input.pack);
+    if (!packDefinition.allowedScopes.includes(input.scope)) {
+        throw new Error(`Pack ${input.pack} does not allow ${input.scope} scope`);
+    }
+    const applicableAssets = packDefinition.assets.filter(({ scopes }) => scopes.includes(input.scope));
+    const changedCanonicalPaths = [];
+    const operations = [];
+    const retainedAssets = input.retainedAssets ?? [];
+    for (const asset of applicableAssets) {
+        const assetOperations = input.action === 'remove'
+            ? [removalOperation(asset, input)].filter((operation) => operation !== null)
+            : materializationOperations(asset, input);
+        operations.push(...assetOperations);
+        if (assetOperations.length > 0) {
+            const path = canonicalPath(asset);
+            if (path)
+                changedCanonicalPaths.push(path);
+        }
+    }
+    const desiredIntent = input.action !== 'remove';
+    if (input.inventory.intent.enabled !== desiredIntent ||
+        (desiredIntent && input.inventory.intent.source !== 'declared')) {
+        operations.push({
+            kind: 'write-intent',
+            pack: input.pack,
+            scope: input.scope,
+            enabled: desiredIntent,
+        });
+    }
+    const managedAssets = applicableAssets.filter((asset) => asset.ownership[input.scope] === 'managed');
+    const retainedPresent = managedAssets.filter((asset) => retainedAssets.some(({ assetId }) => assetId === asset.id) &&
+        input.inventory.assets.some(({ definition, status }) => definition.id === asset.id && status !== 'missing')).length;
+    const expectedRemovalCompleteness = retainedPresent === 0
+        ? 'absent'
+        : retainedPresent === managedAssets.length
+            ? 'complete'
+            : 'partial';
+    return {
+        pack: input.pack,
+        scope: input.scope,
+        action: input.action,
+        operations,
+        expectedCompleteness: input.action === 'remove' ? expectedRemovalCompleteness : 'complete',
+        changedCanonicalPaths: [...new Set(changedCanonicalPaths)],
+        retainedAssets,
+    };
+}
+export function serializePackReconcilePlan(plan) {
+    return JSON.stringify(plan, null, 2);
+}

package/dist/commands/tools/shared/project-tools-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-tools-config.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/project-tools-config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAIf,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAa,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,SAAS,CAAC;AAalD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,8BAA8B;IAC7C,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxE;AA8CD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,4BAA4B,EACrC,YAAY,GAAE,8BAAoD,GACjE,OAAO,CAAC,SAAS,GAAG,WAAW,CAAC,CAuBlC"}
+{"version":3,"file":"project-tools-config.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/project-tools-config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAIf,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAa,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,8BAA8B;IAC7C,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxE;AASD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,4BAA4B,EACrC,YAAY,GAAE,8BAAoD,GACjE,OAAO,CAAC,SAAS,GAAG,WAAW,CAAC,CA2BlC"}