agentic-workflow-manager 3.0.1 → 3.2.0

package/dist/tests/core/init/provider-facts.test.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('gatherProviderFacts / assertClaudeBaselinePreserved', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-facts-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('two snapshots of untouched state are identical (no false positive)', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const before = gatherProviderFacts('claude-code');
+        const after = gatherProviderFacts('claude-code');
+        expect(() => assertClaudeBaselinePreserved(before, after)).not.toThrow();
+        expect(before.hash).toBe(after.hash);
+    });
+    it('detects a top-level file change under a managed directory', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillsDir, 'SKILL.md'), 'original');
+        const before = gatherProviderFacts('claude-code');
+        fs_1.default.writeFileSync(path_1.default.join(skillsDir, 'SKILL.md'), 'mutated');
+        const after = gatherProviderFacts('claude-code');
+        expect(before.hash).not.toBe(after.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+    it('detects a content-only change two levels deep under a managed directory', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        // .claude/skills/some-skill/nested/deep.md — two directory levels below skills/
+        const nested = path_1.default.join(skillsDir, 'some-skill', 'nested');
+        fs_1.default.mkdirSync(nested, { recursive: true });
+        const deepFile = path_1.default.join(nested, 'deep.md');
+        fs_1.default.writeFileSync(deepFile, 'original deep content');
+        const before = gatherProviderFacts('claude-code');
+        // Content-only mutation — no rename, no size-preserving trick needed;
+        // this alone would have been invisible to a top-level-only stat digest.
+        fs_1.default.writeFileSync(deepFile, 'mutated deep content');
+        const after = gatherProviderFacts('claude-code');
+        expect(before.hash).not.toBe(after.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+    it('detects an added file three levels deep without touching any existing file', () => {
+        const { gatherProviderFacts } = require('../../../src/core/init/provider-facts');
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        const nested = path_1.default.join(skillsDir, 'pkg', 'a', 'b');
+        fs_1.default.mkdirSync(nested, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(nested, 'existing.md'), 'unchanged');
+        const before = gatherProviderFacts('claude-code');
+        fs_1.default.writeFileSync(path_1.default.join(nested, 'new-file.md'), 'new');
+        const after = gatherProviderFacts('claude-code');
+        expect(before.hash).not.toBe(after.hash);
+    });
+    it('throws a distinct message when comparing facts for mismatched agents', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const claude = gatherProviderFacts('claude-code');
+        const codex = gatherProviderFacts('codex');
+        expect(() => assertClaudeBaselinePreserved(claude, codex)).toThrow('mismatched agents');
+    });
+    // -----------------------------------------------------------------------
+    // Nested-scriptsDir exclusion (Task 9 fix) — Codex's hook scriptsDir
+    // (~/.awm/hooks/codex) is physically nested inside Claude's own hook
+    // scriptsDir (~/.awm/hooks — providers/index.ts). A naive recursive hash
+    // of Claude's scriptsDir would pick up every Codex hook write as a
+    // "Claude baseline changed" false positive. These two tests pin that
+    // exclusion directly, rather than relying only on the E2E's indirect
+    // before/after tree-snapshot check.
+    // -----------------------------------------------------------------------
+    it('does NOT flag a write inside Codex\'s nested scriptsDir as a Claude baseline change', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        // Seed Claude's own scriptsDir first (mirrors a real prior Claude hook install).
+        const claudeScripts = path_1.default.join(tmpHome, '.awm', 'hooks');
+        fs_1.default.mkdirSync(claudeScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\n');
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'run-hook.cmd'), '#!/bin/sh\n');
+        const before = gatherProviderFacts('claude-code');
+        // Codex's own scriptsDir is nested one level inside Claude's — simulate a
+        // real Codex hook install writing there for the first time.
+        const codexScripts = path_1.default.join(tmpHome, '.awm', 'hooks', 'codex');
+        fs_1.default.mkdirSync(codexScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(codexScripts, 'session-start'), '#!/bin/sh\necho codex\n');
+        const afterAdd = gatherProviderFacts('claude-code');
+        expect(afterAdd.hash).toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, afterAdd)).not.toThrow();
+        // Modifying the Codex-owned nested file's content must also stay invisible.
+        fs_1.default.writeFileSync(path_1.default.join(codexScripts, 'session-start'), '#!/bin/sh\necho codex v2\n');
+        const afterModify = gatherProviderFacts('claude-code');
+        expect(afterModify.hash).toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, afterModify)).not.toThrow();
+    });
+    it('still flags a genuinely Claude-owned change alongside an untouched Codex nested dir', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const claudeScripts = path_1.default.join(tmpHome, '.awm', 'hooks');
+        const codexScripts = path_1.default.join(claudeScripts, 'codex');
+        fs_1.default.mkdirSync(codexScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\n');
+        fs_1.default.writeFileSync(path_1.default.join(codexScripts, 'session-start'), '#!/bin/sh\necho codex\n');
+        const before = gatherProviderFacts('claude-code');
+        // A genuinely Claude-owned file (a sibling of the codex/ subdir, not inside it)
+        // changes — the exclusion must not swallow this.
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\necho mutated claude script\n');
+        const after = gatherProviderFacts('claude-code');
+        expect(after.hash).not.toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+});

package/dist/tests/core/init/steps.test.js

@@ -55,7 +55,7 @@ function spies() {
 function deps(ctx, actions, over = {}) {
     return {
         cwd: '/repo', ctx, bundles: [bundle('dev', 'baseline', ['brainstorming'])],
-        agent: 'claude-code', installMethod: 'symlink',
+        agent: 'claude-code', enabledAgents: ['claude-code'], installMethod: 'symlink',
         registryRoot: '/cache', contentDir: '/cache/registry', sensorPacksRoot: '/cache/registry',
         confirmExtensions: async (p) => p, actions, ...over,
     };
@@ -111,6 +111,22 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
         expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installHook).toHaveBeenCalled();
     });
+    // Regression: a real (unstubbed) `awm init --agent opencode` used to throw
+    // "hooks not supported for agent target: opencode" from installHook,
+    // because stepHook never checked whether the target agent has a hook
+    // mechanism at all before calling installHook (providers/index.ts:
+    // OpenCode/Antigravity have no `hooks` config). Found while building the
+    // real Codex+OpenCode coexistence E2E test — mirrors provider-checks.ts's
+    // `hookTrustCheck`, which already treats a missing `hooks` config as "not
+    // applicable" rather than a failure.
+    it('hook skips (not calls installHook) for an agent with no hook mechanism', () => {
+        const a = spies();
+        const m = machine();
+        m.hook = { present: false };
+        const r = (0, steps_1.stepHook)(deps({ machine: m, project: null }, a, { agent: 'opencode', enabledAgents: ['opencode'] }));
+        expect(r.action).toBe('skipped');
+        expect(a.installHook).not.toHaveBeenCalled();
+    });
     it('devCore installs baseline when links broken', () => {
         const a = spies();
         const m = machine();
@@ -137,6 +153,56 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
         const a = spies();
         expect((0, steps_1.stepAmbient)(deps({ machine: machine(), project: null }, a)).action).toBe('skipped');
     });
+    // Regression coverage for the BLOCKER found in post-implementation QA:
+    // stepDevCore/stepAmbient used to pass a `[d.agent]` singleton as
+    // `agents`, which install-planner.ts's `assertCompleteSharedGroup` (R14)
+    // refuses whenever a co-owner sharing the same physical skill directory
+    // (OpenCode and Codex both resolve to ~/.agents/skills) is independently
+    // enabled — making `awm init --agent codex` structurally fail once
+    // OpenCode was already enabled, and vice versa.
+    it('devCore includes a co-enabled agent sharing the same skill target (codex + opencode)', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        const r = (0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalledWith(expect.objectContaining({ agents: expect.arrayContaining(['codex', 'opencode']) }));
+        const call = a.installBundle.mock.calls[0][0];
+        expect(call.agents).toHaveLength(2); // claude-code is NOT included — it doesn't share the skill target
+    });
+    it('devCore does not add a co-owner that is not currently enabled', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        const r = (0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalledWith(expect.objectContaining({ agents: ['codex'] }));
+    });
+    it('devCore never adds a co-owner for claude-code (its skill dir is never shared)', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        const r = (0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a, {
+            agent: 'claude-code', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalledWith(expect.objectContaining({ agents: ['claude-code'] }));
+    });
+    it('ambient includes a co-enabled agent sharing the same skill target (codex + opencode)', () => {
+        const a = spies();
+        const m = machine();
+        m.ambient = { wanted: ['docs'], installed: [] };
+        const r = (0, steps_1.stepAmbient)(deps({ machine: m, project: null }, a, {
+            agent: 'opencode', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        const call = a.installBundle.mock.calls[0][0];
+        expect(call.agents.sort()).toEqual(['codex', 'opencode']);
+    });
 });
 describe('stepProfile', () => {
     it('adds confirmed extension when detector finds a match', async () => {
@@ -237,6 +303,31 @@ describe('stepActivation', () => {
         (0, steps_1.stepActivation)(deps(ctx, a, { agent: 'opencode' }));
         expect(a.gatherProject).toHaveBeenCalledWith(expect.any(String), expect.any(Array), 'opencode');
     });
+    // Same class of bug as stepDevCore/stepAmbient's shared-group regression
+    // above, in the LOCAL-scope (project) code path: OpenCode and Codex share
+    // both their global AND local skill directories, so a project extension
+    // with a skill artifact hits the identical R14 refusal whenever
+    // syncProfile is called with a `[d.agent]` singleton and a co-owner is
+    // independently enabled.
+    it('activation includes a co-enabled agent sharing the same LOCAL skill target (codex + opencode)', () => {
+        const a = spies();
+        a.gatherProject = jest.fn((_cwd, _bundles) => project({ activeBundles: { expected: ['x'], linked: [], broken: [] } }));
+        const r = (0, steps_1.stepActivation)(deps({ machine: machine(), project: project() }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        const call = a.syncProfile.mock.calls[0][0];
+        expect(call.agents.sort()).toEqual(['codex', 'opencode']);
+    });
+    it('activation does not add a co-owner that is not currently enabled', () => {
+        const a = spies();
+        a.gatherProject = jest.fn((_cwd, _bundles) => project({ activeBundles: { expected: ['x'], linked: [], broken: [] } }));
+        const r = (0, steps_1.stepActivation)(deps({ machine: machine(), project: project() }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.syncProfile).toHaveBeenCalledWith(expect.objectContaining({ agents: ['codex'] }));
+    });
 });
 describe('stepSensors', () => {
     it('skips when sensors present', () => {
@@ -296,7 +387,7 @@ describe('stepGlobalSkillsRepair', () => {
         m.globalSkills = { valid: [], repairable: ['b'], dead: [] };
         const r = (0, steps_1.stepGlobalSkillsRepair)(deps({ machine: m, project: null }, a, { agent: 'opencode' }));
         expect(r.action).toBe('applied');
-        expect(a.repairGlobalSkills).toHaveBeenCalledWith(providers_1.PROVIDERS['opencode'].skill.global, expect.any(Array));
+        expect(a.repairGlobalSkills).toHaveBeenCalledWith((0, providers_1.providerFor)('opencode').skill.global, expect.any(Array));
     });
 });
 describe('stepConstitutionInjection (#6)', () => {
@@ -318,6 +409,12 @@ describe('stepConstitutionInjection (#6)', () => {
         expect(r.action).toBe('skipped');
         expect(a.injectProjectConstitution).not.toHaveBeenCalled();
     });
+    it('installs Codex project guidance before CONSTITUTION.md exists', () => {
+        const a = spies();
+        const r = (0, steps_1.stepConstitutionInjection)(deps({ machine: machine(), project: project({ constitution: { present: false } }) }, a, { agent: 'codex' }));
+        expect(r.action).toBe('applied');
+        expect(a.injectProjectConstitution).toHaveBeenCalledWith({ projectRoot: '/repo', agent: 'codex' });
+    });
     it('maps already → skipped when CONSTITUTION.md was already in opencode.json', () => {
         const a = spies();
         a.injectProjectConstitution.mockReturnValue('already');
@@ -360,4 +457,11 @@ describe('stepContextInjection', () => {
         expect(r.action).toBe('applied');
         expect(a.installContext).toHaveBeenCalled();
     });
+    it('installs the Codex global managed block when absent', () => {
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'codex' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'codex', scope: 'global' }));
+    });
 });

package/dist/tests/core/install-planner.test.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const install_planner_1 = require("../../src/core/install-planner");
+describe('install-planner', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        // Isolate ~ (and thus provider global paths, per CLAUDE.md: no test may
+        // touch the real ~/.awm or ~/.agents). HOME also drives providerFor()'s
+        // global dirs, which is exactly what makes opencode/codex "share" a
+        // physical skills directory in these tests.
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-planner-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-planner-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    function skillArtifact(name) {
+        return {
+            name,
+            installName: name,
+            type: 'skill',
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', name),
+        };
+    }
+    function agentArtifact(name) {
+        return {
+            name,
+            installName: `${name}.md`,
+            type: 'agent',
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'agents', `${name}.md`),
+        };
+    }
+    function workflowArtifact(name) {
+        return {
+            name,
+            installName: `${name}.md`,
+            type: 'workflow',
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'workflows', `${name}.md`),
+        };
+    }
+    function recordOwnedBy(name, owners) {
+        return {
+            name,
+            type: 'skill',
+            scope: 'global',
+            targetPath: path_1.default.join(tmpHome, '.agents', 'skills', name),
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', name),
+            renderer: 'link',
+            owners,
+        };
+    }
+    describe('planInstall', () => {
+        it('deduplicates the OpenCode/Codex physical skill write and reports both owners', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['opencode', 'codex'],
+                enabledAgents: ['claude-code', 'opencode', 'codex'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations).toHaveLength(1); // verifies R15
+            expect(plan.operations[0].owners).toEqual(['opencode', 'codex']); // verifies R15.1
+        });
+        it('aborts a skill change for an incomplete shared target group before writes', () => {
+            expect(() => (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            })).toThrow('select the complete shared target group: opencode,codex'); // verifies R14
+        });
+        it('does not apply the shared-domain restriction to independently addressed agents', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [agentArtifact('development-process')],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations[0].owners).toEqual(['codex']); // verifies R13
+        });
+        it('returns no operations for an empty artifacts array', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan).toEqual({ operations: [], records: [], reports: [] });
+        });
+        it('returns no operations for an empty selectedAgents array', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: [],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan).toEqual({ operations: [], records: [], reports: [] });
+        });
+        it('skips an artifact type unsupported by an agent instead of throwing (workflow on claude-code)', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [workflowArtifact('wf-ext')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations).toEqual([]);
+        });
+        it('resolves a local-scope target beneath projectRoot', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'local',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations[0].targetPath).toBe(path_1.default.join(tmpWork, '.claude', 'skills', 'development-process'));
+        });
+        it('dedupes two intents that share both targetPath and sourcePath into one operation', () => {
+            // e.g. the same skill pulled in twice via different bundles in a
+            // closure — same physical target, same backing source: fine.
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process'), skillArtifact('development-process')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations).toHaveLength(1);
+        });
+        it('throws when two intents share a targetPath but have different sourcePaths', () => {
+            // e.g. the same skill name shipped by two different registries —
+            // one physical target can't be backed by two different sources.
+            const registryA = {
+                name: 'development-process',
+                installName: 'development-process',
+                type: 'skill',
+                sourcePath: path_1.default.join(tmpWork, 'registry-a', 'skills', 'development-process'),
+            };
+            const registryB = {
+                name: 'development-process',
+                installName: 'development-process',
+                type: 'skill',
+                sourcePath: path_1.default.join(tmpWork, 'registry-b', 'skills', 'development-process'),
+            };
+            expect(() => (0, install_planner_1.planInstall)({
+                artifacts: [registryA, registryB],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            })).toThrow(/physical target already claimed by a different source/);
+        });
+    });
+    describe('planRemoval', () => {
+        it('retains a target while a non-selected enabled owner remains', () => {
+            const result = (0, install_planner_1.planRemoval)({
+                records: [recordOwnedBy('development-process', ['opencode', 'codex'])],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                artifactNames: ['development-process'],
+            });
+            expect(result.operations).toEqual([]);
+            expect(result.records[0].owners).toEqual(['opencode']); // verifies R16
+        });
+        it('produces an unlink once the last enabled owner is removed', () => {
+            const result = (0, install_planner_1.planRemoval)({
+                records: [recordOwnedBy('development-process', ['codex'])],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                artifactNames: ['development-process'],
+            });
+            expect(result.records).toEqual([]);
+            expect(result.operations).toHaveLength(1);
+            expect(result.operations[0].action).toBe('unlink');
+        });
+        it('leaves records for artifacts not named in artifactNames untouched', () => {
+            const other = recordOwnedBy('other-skill', ['codex']);
+            const result = (0, install_planner_1.planRemoval)({
+                records: [other],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                artifactNames: ['development-process'],
+            });
+            expect(result.records).toEqual([other]);
+            expect(result.operations).toEqual([]);
+        });
+    });
+});