agentic-workflow-manager 3.0.1 → 3.2.0

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

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/core/install-transaction.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const install_transaction_1 = require("../../src/core/install-transaction");
+const artifact_state_1 = require("../../src/core/artifact-state");
+// Per CLAUDE.md: no test may touch the real ~/.awm. Every test here backs up
+// or transacts through awmHome(), so HOME/AWM_HOME must point at an isolated
+// tmpdir (pattern from tests/commands/hooks/install.test.ts).
+let tmpHome;
+let tmpWork;
+let originalHome;
+let originalAwmHome;
+beforeEach(() => {
+    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-txn-home-'));
+    tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-txn-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 makeOp(name, overrides = {}) {
+    return {
+        name,
+        type: 'skill',
+        scope: 'local',
+        targetPath: path_1.default.join(tmpWork, name),
+        sourcePath: path_1.default.join(tmpWork, `${name}-source`),
+        renderer: 'link',
+        owners: ['claude-code'],
+        method: 'copy',
+        output: 'link',
+        ...overrides,
+    };
+}
+function planWithTwoTargets() {
+    const a = makeOp('a');
+    const b = makeOp('b');
+    return { operations: [a, b], records: [], reports: [] };
+}
+function planWithThreeTargets() {
+    const a = makeOp('a');
+    const b = makeOp('b');
+    const c = makeOp('c');
+    return { operations: [a, b, c], records: [], reports: [] };
+}
+/**
+ * Builds a plan whose second operation ("b") is guaranteed to be replaced
+ * (real filesystem write) before verification runs, letting the test force a
+ * verification failure via a `verify` override while still exercising the
+ * REAL default backup/stage/replace/rollback pipeline underneath.
+ */
+function planThatFailsSecondVerification(original) {
+    const sourceA = path_1.default.join(tmpWork, 'source-a');
+    fs_1.default.mkdirSync(sourceA, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(sourceA, 'file.txt'), 'new-a');
+    const sourceB = path_1.default.join(tmpWork, 'source-b');
+    fs_1.default.mkdirSync(sourceB, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(sourceB, 'file.txt'), 'new-b');
+    const opA = makeOp('a', { targetPath: original, sourcePath: sourceA });
+    const opB = makeOp('b', { targetPath: path_1.default.join(tmpWork, 'target-b'), sourcePath: sourceB });
+    return { operations: [opA, opB], records: [], reports: [] };
+}
+describe('applyInstallPlan', () => {
+    it('validates and backs up every target before the first replacement', () => {
+        const calls = [];
+        (0, install_transaction_1.applyInstallPlan)(planWithTwoTargets(), {
+            validate: (op) => calls.push(`validate:${op.name}`),
+            backup: (op) => { calls.push(`backup:${op.name}`); return null; },
+            stage: (op) => { calls.push(`stage:${op.name}`); return `/staged/${op.name}`; },
+            replace: (op) => calls.push(`replace:${op.name}`),
+            verify: (op) => calls.push(`verify:${op.name}`),
+            rollback: (op) => calls.push(`rollback:${op.name}`),
+        });
+        expect(calls.indexOf('validate:a')).toBeLessThan(calls.indexOf('backup:a'));
+        expect(calls.indexOf('backup:b')).toBeLessThan(calls.indexOf('replace:a')); // verifies R24.1
+    });
+    it('restores already replaced targets when verification fails', () => {
+        const original = path_1.default.join(tmpWork, 'target-a');
+        fs_1.default.mkdirSync(original, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(original, 'sentinel'), 'before');
+        const plan = planThatFailsSecondVerification(original);
+        const deps = {
+            ...(0, install_transaction_1.defaultTransactionDeps)(),
+            verify: (op) => {
+                if (op.name === 'b')
+                    throw new Error('verification failed: forced for test');
+            },
+        };
+        expect(() => (0, install_transaction_1.applyInstallPlan)(plan, deps)).toThrow('verification failed');
+        expect(fs_1.default.readFileSync(path_1.default.join(original, 'sentinel'), 'utf8')).toBe('before'); // verifies R25
+    });
+    it('returns a transactionId and the list of modified files on success', () => {
+        const sourceA = path_1.default.join(tmpWork, 'source-a');
+        fs_1.default.mkdirSync(sourceA, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(sourceA, 'file.txt'), 'content-a');
+        const targetA = path_1.default.join(tmpWork, 'target-a');
+        const plan = {
+            operations: [makeOp('a', { targetPath: targetA, sourcePath: sourceA })],
+            records: [],
+            reports: [{ owner: 'claude-code', targetPath: targetA, action: 'install' }],
+        };
+        const summary = (0, install_transaction_1.applyInstallPlan)(plan);
+        expect(summary.transactionId).toBeTruthy();
+        expect(summary.modifiedFiles).toEqual([targetA]);
+        expect(fs_1.default.existsSync(path_1.default.join(targetA, 'file.txt'))).toBe(true);
+        const backupDir = path_1.default.join(process.env.AWM_HOME, 'backups', summary.transactionId);
+        expect(fs_1.default.existsSync(path_1.default.join(backupDir, 'manifest.json'))).toBe(true);
+    });
+    it('is a safe no-op for an empty plan', () => {
+        const summary = (0, install_transaction_1.applyInstallPlan)({ operations: [], records: [], reports: [] });
+        expect(summary.installed).toEqual([]);
+        expect(summary.modifiedFiles).toEqual([]);
+        expect(summary.transactionId).toBeTruthy();
+    });
+    it('keeps rolling back remaining targets, and still surfaces the original error, when a MIDDLE rollback fails', () => {
+        // 3 ops (a, b, c) all replaced; verification fails on 'c', so rollback
+        // runs in reverse order: c, b, a. Making 'b' — the middle op in that
+        // reversed order, with an op both before and after it in the loop —
+        // the one that throws is what actually proves the per-op try/catch
+        // isolates failures: 'a' still runs AFTER 'b' throws, not just
+        // trivially "nothing left to run" as a last-in-order failure would.
+        const calls = [];
+        const plan = planWithThreeTargets();
+        expect(() => (0, install_transaction_1.applyInstallPlan)(plan, {
+            validate: () => { },
+            backup: () => null,
+            stage: (op) => `/staged/${op.name}`,
+            replace: (op) => calls.push(`replace:${op.name}`),
+            verify: (op) => { if (op.name === 'c')
+                throw new Error('verification failed: forced'); },
+            rollback: (op) => {
+                calls.push(`rollback:${op.name}`);
+                if (op.name === 'b')
+                    throw new Error('rollback failed for b (simulated)');
+            },
+        })).toThrow('verification failed: forced');
+        // All three replaced ops got a rollback attempt, in reverse order —
+        // including 'a', which runs strictly after 'b' throws, proving the
+        // loop doesn't stop or skip ahead when a non-terminal rollback fails.
+        expect(calls).toEqual(['replace:a', 'replace:b', 'replace:c', 'rollback:c', 'rollback:b', 'rollback:a']);
+    });
+    describe('artifact-state persistence across multiple calls (BLOCKER regression)', () => {
+        // A real `awm init` run makes several separate applyInstallPlan calls
+        // in sequence — one per bundle (dev-core, each ambient bundle, each
+        // synced project extension). Each call's plan.records only covers the
+        // artifacts THAT call touched. Persisting must be additive: an
+        // earlier call's ownership records must survive a later call, not be
+        // silently discarded by a wholesale overwrite of state/artifacts.json.
+        function sourceFor(name) {
+            const src = path_1.default.join(tmpWork, `${name}-source`);
+            fs_1.default.mkdirSync(src, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(src, 'file.txt'), name);
+            return src;
+        }
+        function planFor(name, targetPath) {
+            const op = makeOp(name, { targetPath, sourcePath: sourceFor(name) });
+            return { operations: [op], records: [op], reports: [{ owner: 'claude-code', targetPath, action: 'install' }] };
+        }
+        it('preserves an earlier applyInstallPlan call’s records after a later call for a DIFFERENT target', () => {
+            const targetA = path_1.default.join(tmpWork, 'target-a');
+            const targetB = path_1.default.join(tmpWork, 'target-b');
+            (0, install_transaction_1.applyInstallPlan)(planFor('a', targetA));
+            (0, install_transaction_1.applyInstallPlan)(planFor('b', targetB));
+            const state = (0, artifact_state_1.readArtifactState)();
+            expect(state.map((r) => r.targetPath).sort()).toEqual([targetA, targetB].sort());
+        });
+        it('replaces (does not duplicate) the record for a targetPath touched by two separate applyInstallPlan calls', () => {
+            const targetA = path_1.default.join(tmpWork, 'target-a');
+            (0, install_transaction_1.applyInstallPlan)(planFor('a', targetA));
+            const secondOp = makeOp('a', { targetPath: targetA, sourcePath: sourceFor('a2'), owners: ['claude-code', 'codex'] });
+            (0, install_transaction_1.applyInstallPlan)({
+                operations: [secondOp],
+                records: [secondOp],
+                reports: [{ owner: 'codex', targetPath: targetA, action: 'retain' }],
+            });
+            const state = (0, artifact_state_1.readArtifactState)();
+            expect(state).toHaveLength(1);
+            expect(state[0].targetPath).toBe(targetA);
+            expect(state[0].owners).toEqual(['claude-code', 'codex']);
+        });
+    });
+});
+describe('beginBackupSession / restoreBackup', () => {
+    it('backs up existing targets before mutation and restores them on rollback', () => {
+        const fileA = path_1.default.join(tmpWork, 'a.json');
+        const fileB = path_1.default.join(tmpWork, 'b.json');
+        fs_1.default.writeFileSync(fileA, 'A-before');
+        fs_1.default.writeFileSync(fileB, 'B-before');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA, fileB]);
+        fs_1.default.writeFileSync(fileA, 'A-after');
+        fs_1.default.writeFileSync(fileB, 'B-after');
+        session.rollback();
+        expect(fs_1.default.readFileSync(fileA, 'utf8')).toBe('A-before');
+        expect(fs_1.default.readFileSync(fileB, 'utf8')).toBe('B-before');
+    });
+    it('removes a target that did not exist before the session, on rollback', () => {
+        const newFile = path_1.default.join(tmpWork, 'created.json');
+        const session = (0, install_transaction_1.beginBackupSession)([newFile]);
+        fs_1.default.writeFileSync(newFile, 'created content');
+        session.rollback();
+        expect(fs_1.default.existsSync(newFile)).toBe(false);
+    });
+    it('commit marks the manifest committed without restoring anything', () => {
+        const fileA = path_1.default.join(tmpWork, 'c.json');
+        fs_1.default.writeFileSync(fileA, 'C-before');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA]);
+        fs_1.default.writeFileSync(fileA, 'C-after');
+        session.commit();
+        expect(fs_1.default.readFileSync(fileA, 'utf8')).toBe('C-after');
+        const manifestPath = path_1.default.join(process.env.AWM_HOME, 'backups', session.transactionId, 'manifest.json');
+        const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+        expect(manifest.committed).toBe(true);
+    });
+    it('refuses to back up a filesystem root', () => {
+        expect(() => (0, install_transaction_1.beginBackupSession)(['/'])).toThrow('refusing to back up a filesystem root');
+    });
+    it('creates the backup directory and manifest with restrictive permissions, no content leaked', () => {
+        const fileA = path_1.default.join(tmpWork, 'perm.json');
+        fs_1.default.writeFileSync(fileA, 'secret-content');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA]);
+        const backupDir = path_1.default.join(process.env.AWM_HOME, 'backups', session.transactionId);
+        const dirMode = fs_1.default.statSync(backupDir).mode & 0o777;
+        const manifestPath = path_1.default.join(backupDir, 'manifest.json');
+        const manifestMode = fs_1.default.statSync(manifestPath).mode & 0o777;
+        expect(dirMode).toBe(0o700);
+        expect(manifestMode).toBe(0o600);
+        const manifestRaw = fs_1.default.readFileSync(manifestPath, 'utf8');
+        expect(manifestRaw).not.toContain('secret-content');
+    });
+    it('restoreBackup restores exactly the manifest targets', () => {
+        const fileA = path_1.default.join(tmpWork, 'd.json');
+        fs_1.default.writeFileSync(fileA, 'D-before');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA]);
+        fs_1.default.writeFileSync(fileA, 'D-after');
+        const result = (0, install_transaction_1.restoreBackup)(session.transactionId);
+        expect(result.restored).toEqual([fileA]);
+        expect(fs_1.default.readFileSync(fileA, 'utf8')).toBe('D-before');
+    });
+});

package/dist/tests/core/provider-artifacts.test.js

@@ -0,0 +1,64 @@
+"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 provider_artifacts_1 = require("../../src/core/provider-artifacts");
+describe('preflightLinkArtifactPairs', () => {
+    it('rejects a mixed Codex selection before any installer call', () => {
+        const install = jest.fn();
+        expect(() => {
+            const pairs = [
+                { agent: 'codex', artifact: { type: 'skill', name: 'linked-skill' } },
+                { agent: 'codex', artifact: { type: 'agent', name: 'toml-agent' } },
+            ];
+            (0, provider_artifacts_1.preflightLinkArtifactPairs)(pairs);
+            for (const item of pairs)
+                install(item);
+        }).toThrow("Renderer 'codex-agent-toml' for codex agent artifacts is not implemented yet");
+        expect(install).not.toHaveBeenCalled();
+    });
+});
+describe('scanLegacyArtifacts', () => {
+    const originalHome = process.env.HOME;
+    const originalAwmHome = process.env.AWM_HOME;
+    let tmpHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-artifacts-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+    });
+    afterEach(() => {
+        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;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    });
+    it('never lists Codex TOML agents for legacy removal', () => {
+        const skillPath = path_1.default.join(tmpHome, '.agents/skills/linked-skill');
+        const agentPath = path_1.default.join(tmpHome, '.codex/agents/protected.toml');
+        fs_1.default.mkdirSync(skillPath, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.dirname(agentPath), { recursive: true });
+        fs_1.default.writeFileSync(agentPath, 'name = "protected"\n');
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['codex'], 'global');
+        const legacyRemove = jest.fn((target) => fs_1.default.rmSync(target, {
+            recursive: true,
+            force: true,
+        }));
+        for (const artifact of listed) {
+            for (const fullPath of artifact.fullPaths)
+                legacyRemove(fullPath);
+        }
+        expect(listed.map((artifact) => artifact.name)).toEqual(['linked-skill']);
+        expect(legacyRemove).not.toHaveBeenCalledWith(agentPath);
+        expect(fs_1.default.existsSync(agentPath)).toBe(true);
+    });
+});

package/dist/tests/core/provider-version.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_version_1 = require("../../src/core/provider-version");
+describe('assertProviderSupported', () => {
+    it('accepts the current stable Codex line', () => {
+        const exec = jest.fn(() => Buffer.from('codex-cli 0.145.0\n'));
+        expect((0, provider_version_1.assertProviderSupported)('codex', exec)).toEqual({
+            provider: 'codex',
+            version: '0.145.0',
+        });
+        expect(exec).toHaveBeenCalledWith('codex', ['--version'], expect.any(Object));
+    });
+    it.each(['0.145.1', '0.146.0', '1.0.0'])('accepts stable Codex version %s above the minimum', (version) => {
+        expect((0, provider_version_1.assertProviderSupported)('codex', () => Buffer.from(`codex-cli ${version}\n`))).toEqual({ provider: 'codex', version });
+    });
+    it.each([
+        [Buffer.from('codex-cli 0.144.9\n'), 'requires Codex >= 0.145.0'],
+        [Buffer.from('unknown\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli 0.145.0-beta.1\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli v0.145.0\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli 0.145\n'), 'could not parse Codex version'],
+        [Buffer.from('unexpected-tool 9.9.9\n'), 'could not parse Codex version'],
+        [Buffer.from('notice: codex-cli 0.145.0\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli stable 0.145.0\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli 0.145.0 trailing\n'), 'could not parse Codex version'],
+    ])('rejects unsupported output without mutation', (output, message) => {
+        expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => output)).toThrow(message);
+    });
+    it('returns a null version for providers without a version gate', () => {
+        const exec = jest.fn();
+        expect((0, provider_version_1.assertProviderSupported)('claude-code', exec)).toEqual({
+            provider: 'claude-code',
+            version: null,
+        });
+        expect(exec).not.toHaveBeenCalled();
+    });
+    it('reports a missing Codex binary distinctly', () => {
+        const missing = Object.assign(new Error('spawnSync codex ENOENT'), { code: 'ENOENT' });
+        expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => { throw missing; }))
+            .toThrow('Codex is not installed or not available on PATH');
+    });
+    it('reports other Codex probe failures distinctly', () => {
+        expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => {
+            throw new Error('permission denied');
+        })).toThrow('Codex version probe failed: permission denied');
+    });
+    it('fails loudly for invalid runtime provider input', () => {
+        const exec = jest.fn();
+        expect(() => (0, provider_version_1.assertProviderSupported)('invalid', exec))
+            .toThrow('Unknown agent target');
+        expect(exec).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/core/reconciliation.test.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/core/reconciliation.test.ts
+//
+// Exercises the REAL planReconciliation (no mocks) end-to-end: seeds a real
+// registry content root with a baseline bundle, an ambient bundle, and a
+// project-scope bundle, then verifies the computed plan only reconciles the
+// machine-scope (baseline + ambient) artifacts — and, applied via the real
+// applyInstallPlan, actually fixes both a MISSING target and a STALE target.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function writeBundle(contentRoot, name, scope, skills, dependsOn = []) {
+    fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'bundles', name), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'bundles', name, 'bundle.json'), JSON.stringify({
+        name, version: '1.0.0', scope, dependsOn,
+        skills: skills.map((s) => ({ name: s })), workflows: [], agents: [],
+    }));
+    for (const skill of skills) {
+        fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', skill), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'skills', skill, 'SKILL.md'), `# ${skill}`);
+    }
+}
+function addToCatalog(contentRoot, name, scope) {
+    const catalogFile = path_1.default.join(contentRoot, 'catalog.json');
+    const catalog = JSON.parse(fs_1.default.readFileSync(catalogFile, 'utf-8'));
+    catalog.bundles.push({ name, source: `./bundles/${name}`, version: '1.0.0', scope });
+    fs_1.default.writeFileSync(catalogFile, JSON.stringify(catalog));
+}
+describe('planReconciliation (real, unmocked)', () => {
+    let tmpHome;
+    let contentRoot;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-reconcile-'));
+        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();
+        contentRoot = path_1.default.join(tmpHome, 'registry');
+        fs_1.default.mkdirSync(contentRoot, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'catalog.json'), JSON.stringify({
+            version: 1,
+            bundles: [
+                { name: 'dev', source: './bundles/dev', version: '1.0.0', scope: 'baseline' },
+                { name: 'ambient-x', source: './bundles/ambient-x', version: '1.0.0', scope: 'ambient' },
+                { name: 'proj-y', source: './bundles/proj-y', version: '1.0.0', scope: 'project' },
+            ],
+        }));
+        writeBundle(contentRoot, 'dev', 'baseline', ['brainstorming']);
+        writeBundle(contentRoot, 'ambient-x', 'ambient', ['ambient-skill']);
+        writeBundle(contentRoot, 'proj-y', 'project', ['proj-skill']);
+    });
+    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('plans only the machine-scope (baseline + ambient) artifacts, excluding project-scope bundles', () => {
+        const { planReconciliation } = require('../../src/core/reconciliation');
+        const plan = planReconciliation({ targets: ['claude-code'], roots: [contentRoot] });
+        const names = plan.operations.map((op) => op.name).sort();
+        expect(names).toEqual(['ambient-skill', 'brainstorming']); // proj-skill excluded (R — project bundles are `awm sync`'s job, not `awm update`'s)
+        const claudeSkillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        const targets = plan.operations.map((op) => op.targetPath).sort();
+        expect(targets).toEqual([
+            path_1.default.join(claudeSkillsDir, 'ambient-skill'),
+            path_1.default.join(claudeSkillsDir, 'brainstorming'),
+        ]);
+    });
+    it('reconciles drift end-to-end when applied: installs a MISSING target and replaces a STALE one', () => {
+        const claudeSkillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        fs_1.default.mkdirSync(claudeSkillsDir, { recursive: true });
+        // Drift scenario 1 — stale: 'brainstorming' exists but as a plain file
+        // with the wrong content (as if it were copied once and the registry
+        // has since diverged), not a symlink to the registry source.
+        fs_1.default.writeFileSync(path_1.default.join(claudeSkillsDir, 'brainstorming'), 'stale, wrong content');
+        // Drift scenario 2 — missing: 'ambient-skill' was never installed at all.
+        expect(fs_1.default.existsSync(path_1.default.join(claudeSkillsDir, 'ambient-skill'))).toBe(false);
+        const { planReconciliation } = require('../../src/core/reconciliation');
+        const { applyInstallPlan } = require('../../src/core/install-transaction');
+        const plan = planReconciliation({ targets: ['claude-code'], roots: [contentRoot] });
+        const summary = applyInstallPlan(plan);
+        expect(summary.installed.sort()).toEqual([
+            'ambient-skill → claude-code',
+            'brainstorming → claude-code',
+        ]);
+        // Stale target is now a real symlink to the registry source, not the old file.
+        const brainstormingStat = fs_1.default.lstatSync(path_1.default.join(claudeSkillsDir, 'brainstorming'));
+        expect(brainstormingStat.isSymbolicLink()).toBe(true);
+        expect(fs_1.default.realpathSync(path_1.default.join(claudeSkillsDir, 'brainstorming')))
+            .toBe(fs_1.default.realpathSync(path_1.default.join(contentRoot, 'skills', 'brainstorming')));
+        // Missing target now exists as a symlink too.
+        const ambientStat = fs_1.default.lstatSync(path_1.default.join(claudeSkillsDir, 'ambient-skill'));
+        expect(ambientStat.isSymbolicLink()).toBe(true);
+        expect(fs_1.default.realpathSync(path_1.default.join(claudeSkillsDir, 'ambient-skill')))
+            .toBe(fs_1.default.realpathSync(path_1.default.join(contentRoot, 'skills', 'ambient-skill')));
+    });
+    it('scopes to the selected agent target only', () => {
+        const { planReconciliation } = require('../../src/core/reconciliation');
+        const plan = planReconciliation({ targets: ['opencode'], roots: [contentRoot] });
+        const owners = new Set(plan.operations.flatMap((op) => op.owners));
+        expect(owners).toEqual(new Set(['opencode']));
+    });
+    // NOTE on the two tests below: `resolveBundleClosure` (bundles.ts) already
+    // treats a `dependsOn` entry naming a bundle that isn't in the catalog as
+    // silently absent from the closure — it does NOT throw (verified directly:
+    // a baseline bundle with `dependsOn: ['does-not-exist']` resolves its own
+    // artifacts fine; the ghost name is just dropped). So a plain dangling
+    // `dependsOn` string never reaches `planReconciliation`'s
+    // `try { expandBundleArtifacts(...) } catch { continue; }` guard at all —
+    // the first test below confirms that directly. To actually force the catch
+    // branch (and check it skips only the one broken bundle, not the whole
+    // batch, and doesn't silently eat some other bug), the second test injects
+    // a bundle whose `dependsOn` field is malformed in a way that genuinely
+    // breaks closure resolution (`dependsOn` is not an array, so
+    // `resolveBundleClosure`'s `for (const dep of b.dependsOn)` throws) —
+    // mirroring the kind of real, unresolvable-closure error the catch is
+    // meant to guard against.
+    it('tolerates a plain dangling dependsOn reference without needing the catch — the bundle installs normally', () => {
+        writeBundle(contentRoot, 'dangling-dep', 'baseline', ['dangling-skill'], ['does-not-exist']);
+        addToCatalog(contentRoot, 'dangling-dep', 'baseline');
+        const { planReconciliation } = require('../../src/core/reconciliation');
+        const plan = planReconciliation({ targets: ['claude-code'], roots: [contentRoot] });
+        const names = plan.operations.map((op) => op.name).sort();
+        // 'dangling-skill' installs fine even though its bundle's dependsOn
+        // points nowhere — resolveBundleClosure just drops the missing dep.
+        expect(names).toEqual(['ambient-skill', 'brainstorming', 'dangling-skill']);
+    });
+    it('skips a bundle whose closure genuinely fails to resolve, without aborting reconciliation for the rest', () => {
+        // Malformed dependsOn (not an array) makes resolveBundleClosure throw
+        // when it tries to iterate it — a real "unresolvable closure" error,
+        // unlike a plain dangling name reference (see test above).
+        writeBundle(contentRoot, 'broken', 'baseline', ['broken-skill'], 5);
+        addToCatalog(contentRoot, 'broken', 'baseline');
+        const { planReconciliation } = require('../../src/core/reconciliation');
+        let plan;
+        expect(() => {
+            plan = planReconciliation({ targets: ['claude-code'], roots: [contentRoot] });
+        }).not.toThrow();
+        // The healthy bundles (baseline 'dev' + ambient 'ambient-x') still
+        // reconcile correctly.
+        const names = plan.operations.map((op) => op.name).sort();
+        expect(names).toEqual(['ambient-skill', 'brainstorming']);
+        // The broken bundle is cleanly absent — no partial/broken entry for
+        // 'broken-skill' or any operation touching it.
+        expect(names).not.toContain('broken-skill');
+        expect(plan.operations.some((op) => op.sourcePath?.includes('broken'))).toBe(false);
+        // Applying the plan end-to-end still works (no dangling reference to
+        // the broken bundle leaked into the plan).
+        const { applyInstallPlan } = require('../../src/core/install-transaction');
+        expect(() => applyInstallPlan(plan)).not.toThrow();
+    });
+});

package/dist/tests/core/registries-sync.test.js

@@ -93,7 +93,7 @@ describe('syncRegistries (git fixtures locales)', () => {
         m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
         const awmDir = path_1.default.join(tmpHome, '.awm');
         fs_1.default.mkdirSync(awmDir, { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude', installMethod: 'symlink', defaultScope: 'local', pins: { personal: '9.9.9' } }));
+        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude-code', installMethod: 'symlink', defaultScope: 'local', pins: { personal: '9.9.9' } }));
         const results = await m.syncRegistries();
         expect(results[0].action).toBe('error');
         // El dir no debe quedar en disco tras el fallo
@@ -110,7 +110,7 @@ describe('syncRegistries (git fixtures locales)', () => {
         m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
         const awmDir = path_1.default.join(tmpHome, '.awm');
         fs_1.default.mkdirSync(awmDir, { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude', installMethod: 'symlink', defaultScope: 'local', pins: { personal: '1.0.0' } }));
+        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude-code', installMethod: 'symlink', defaultScope: 'local', pins: { personal: '1.0.0' } }));
         const results = await m.syncRegistries();
         expect(results).toEqual([{ name: 'personal', action: 'recloned', version: 'v1.0.0' }]);
     });
@@ -174,7 +174,7 @@ describe('syncRegistries (git fixtures locales)', () => {
         expect(r1).toEqual([{ name: 'personal', action: 'recloned', version: 'v1.1.0' }]);
         // establece pin a la versión anterior
         const awmDir = path_1.default.join(tmpHome, '.awm');
-        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude', installMethod: 'symlink', defaultScope: 'local', pins: { personal: '1.0.0' } }));
+        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude-code', installMethod: 'symlink', defaultScope: 'local', pins: { personal: '1.0.0' } }));
         // segunda sync con pin: retrocede a v1.0.0
         const r2 = await m.syncRegistries();
         expect(r2).toEqual([{ name: 'personal', action: 'pulled', version: 'v1.0.0' }]);
@@ -188,7 +188,7 @@ describe('syncRegistries (git fixtures locales)', () => {
         m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
         const awmDir = path_1.default.join(tmpHome, '.awm');
         fs_1.default.mkdirSync(awmDir, { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude', installMethod: 'symlink', defaultScope: 'local', channel: 'dev' }));
+        fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude-code', installMethod: 'symlink', defaultScope: 'local', channel: 'dev' }));
         // primera sync en canal dev: queda en HEAD (no en el tag)
         const r1 = await m.syncRegistries();
         expect(r1).toEqual([{ name: 'personal', action: 'recloned', version: 'HEAD' }]);

package/dist/tests/core/renderers/canonical-agent.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const canonical_agent_1 = require("../../../src/core/renderers/canonical-agent");
+// Real canonical agent content from the awm-baseline-registry (registries/baseline/agents/development-process.md),
+// which the installer materializes at ~/.awm/registries/baseline/agents/development-process.md.
+const canonicalWithModePrimary = `---
+name: development-process
+description: Use as agent profile to orchestrate the development lifecycle - invokes the development-process skill which contains the full orchestration logic
+mode: primary
+---
+
+# Development Process Orchestrator
+
+You are a development orchestrator. You do NOT write code directly.
+
+## On Every Conversation Start
+
+1. **Invoke the \`development-process\` skill.** This skill contains the complete orchestration logic: state detection, lifecycle phases, decision rules, and the full catalog of available skills.
+2. Follow the skill's instructions exactly - it will guide you through identifying project state, recommending the next phase, and delegating to the correct skill.
+
+## Rules
+
+- NEVER start writing code without first invoking \`development-process\`
+- NEVER duplicate orchestration logic here - the skill is the single source of truth
+- NEVER invoke a downstream skill without user approval
+`;
+it('parses name, description, and instructions from valid frontmatter', () => {
+    const source = `---
+name: my-agent
+description: Does a thing
+---
+
+Body text here.
+`;
+    expect((0, canonical_agent_1.parseCanonicalAgent)(source)).toEqual({
+        name: 'my-agent',
+        description: 'Does a thing',
+        instructions: 'Body text here.',
+    });
+});
+it('ignores provider-only mode while retaining canonical instructions', () => {
+    const parsed = (0, canonical_agent_1.parseCanonicalAgent)(canonicalWithModePrimary);
+    expect(parsed).toEqual({
+        name: 'development-process',
+        description: 'Use as agent profile to orchestrate the development lifecycle - invokes the development-process skill which contains the full orchestration logic',
+        instructions: expect.stringContaining('You do NOT write code directly.'),
+    }); // verifies R8, R9
+});
+it.each([
+    ['---\nname: Bad Name\ndescription: x\n---\nbody', 'invalid agent name'],
+    ['---\nname: ok\ndescription:\n---\nbody', 'non-empty description'],
+    ['---\nname: ok\ndescription: x\n---\n', 'non-empty instruction body'],
+    ['name: ok', 'frontmatter'],
+    ['---\nname: ok\nnot a field\n---\nbody', 'invalid canonical agent frontmatter line'],
+    ['---\nname: ok\ndescription: first\ndescription: second\n---\nbody', 'duplicate canonical agent frontmatter key: description'],
+])('rejects invalid canonical agent sources', (source, message) => {
+    expect(() => (0, canonical_agent_1.parseCanonicalAgent)(source)).toThrow(message); // verifies R17
+});