agentic-workflow-manager 2.0.0

package/dist/tests/commands/sensors/status.test.js

@@ -0,0 +1,98 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const status_1 = require("../../../src/commands/sensors/status");
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+const mockExecSync = child_process_1.execSync;
+describe('computeSensorStatus', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-'));
+        mockExecSync.mockReset();
+    });
+    afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
+    it('returns NOT_CONFIGURED when .awm/sensors.json missing', () => {
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('NOT_CONFIGURED');
+        expect(result.pack).toBeNull();
+    });
+    // Helper: simulate a tool installed locally (node_modules/.bin/<tool>)
+    function installLocalBin(tool) {
+        const binDir = path_1.default.join(tmpDir, 'node_modules', '.bin');
+        fs_1.default.mkdirSync(binDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(binDir, tool), '');
+    }
+    it('returns HEALTHY when an npx tool is installed locally', () => {
+        installLocalBin('tsc');
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'js-ts',
+            sensors: { typecheck: { cmd: 'npx tsc --noEmit', fast: true } }
+        }));
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('HEALTHY');
+        expect(result.pack).toBe('js-ts');
+        expect(result.checks.typecheck.ok).toBe(true);
+    });
+    it('marks an npx sensor DEGRADED when the tool is NOT installed locally (npx would fetch a remote package)', () => {
+        // No node_modules/.bin/depcruise → status must NOT report ✔ just because npx exists.
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'js-ts',
+            sensors: { depcheck: { cmd: 'npx depcruise --config .dep-cruiser.awm.js app', fast: false } }
+        }));
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('DEGRADED');
+        expect(result.checks.depcheck.ok).toBe(false);
+        expect(result.checks.depcheck.detail).toMatch(/no instalada/i);
+    });
+    it('marks a sensor DEGRADED when its --config file is missing', () => {
+        installLocalBin('eslint');
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'js-ts',
+            sensors: { lint: { cmd: 'npx eslint . --config eslint.config.awm.mjs --format json', fast: true } }
+        }));
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.checks.lint.ok).toBe(false);
+        expect(result.checks.lint.detail).toMatch(/config faltante/i);
+    });
+    it('is HEALTHY when the npx tool is installed and the --config file exists', () => {
+        installLocalBin('eslint');
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'eslint.config.awm.mjs'), 'export default []');
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'js-ts',
+            sensors: { lint: { cmd: 'npx eslint . --config eslint.config.awm.mjs --format json', fast: true } }
+        }));
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.checks.lint.ok).toBe(true);
+    });
+    it('returns DEGRADED when a binary is missing', () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'js-ts',
+            sensors: { security: { cmd: 'semgrep --json .', fast: false } }
+        }));
+        mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('DEGRADED');
+        expect(result.checks.security.ok).toBe(false);
+    });
+    it('marks disabled sensors as ok', () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'js-ts',
+            sensors: { mutation: { enabled: false } }
+        }));
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.checks.mutation.ok).toBe(true);
+        expect(result.checks.mutation.detail).toBe('disabled');
+    });
+});

package/dist/tests/core/base-remote.test.js

@@ -0,0 +1,70 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('resolveBaseRemote', () => {
+    let tmpHome;
+    const origHome = process.env.HOME;
+    const origAwmHome = process.env.AWM_HOME;
+    const origEnvRemote = process.env.AWM_BASE_REMOTE;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-remote-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        delete process.env.AWM_BASE_REMOTE;
+        jest.resetModules();
+    });
+    afterEach(() => {
+        process.env.HOME = origHome;
+        if (origAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = origAwmHome;
+        if (origEnvRemote === undefined)
+            delete process.env.AWM_BASE_REMOTE;
+        else
+            process.env.AWM_BASE_REMOTE = origEnvRemote;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    });
+    it('falls back to DEFAULT_REMOTE when no env and no prefs', () => {
+        const { resolveBaseRemote, DEFAULT_REMOTE } = require('../../src/core/registry');
+        expect(resolveBaseRemote()).toBe(DEFAULT_REMOTE);
+    });
+    it('prefers preferences.json baseRemote over the default', () => {
+        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-code', installMethod: 'symlink', defaultScope: 'local', baseRemote: 'git@team:content.git' }));
+        const { resolveBaseRemote } = require('../../src/core/registry');
+        expect(resolveBaseRemote()).toBe('git@team:content.git');
+    });
+    it('env AWM_BASE_REMOTE wins over prefs and default', () => {
+        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-code', installMethod: 'symlink', defaultScope: 'local', baseRemote: 'git@team:content.git' }));
+        process.env.AWM_BASE_REMOTE = 'git@env:wins.git';
+        jest.resetModules();
+        const { resolveBaseRemote } = require('../../src/core/registry');
+        expect(resolveBaseRemote()).toBe('git@env:wins.git');
+    });
+    it('resolveBaseRemoteInfo reports where the remote came from', () => {
+        const { resolveBaseRemoteInfo, DEFAULT_REMOTE } = require('../../src/core/registry');
+        // default
+        expect(resolveBaseRemoteInfo()).toEqual({ remote: DEFAULT_REMOTE, source: 'default' });
+        // prefs
+        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-code', installMethod: 'symlink', defaultScope: 'local', baseRemote: 'git@prefs:content.git' }));
+        jest.resetModules();
+        const m2 = require('../../src/core/registry');
+        expect(m2.resolveBaseRemoteInfo()).toEqual({ remote: 'git@prefs:content.git', source: 'prefs' });
+        // env wins over prefs
+        process.env.AWM_BASE_REMOTE = 'git@env:x.git';
+        jest.resetModules();
+        const m3 = require('../../src/core/registry');
+        expect(m3.resolveBaseRemoteInfo()).toEqual({ remote: 'git@env:x.git', source: 'env' });
+    });
+});

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

@@ -0,0 +1,198 @@
+"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 bundles_1 = require("../../src/core/bundles");
+const bundle_install_1 = require("../../src/core/bundle-install");
+const profile_1 = require("../../src/core/profile");
+/**
+ * Builds a fixture with:
+ *  - content registry: catalog + two project bundles (base, ext dependsOn base),
+ *    plus a skill dir per skill, one workflow .md and one agent .md.
+ *  - a separate empty project root for local installs.
+ * Both bundles are `project` scope so every artifact lands under projectRoot/.claude.
+ */
+function makeFixture() {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-binstall-'));
+    const content = path_1.default.join(tmp, 'registry');
+    const projectRoot = path_1.default.join(tmp, 'project');
+    fs_1.default.mkdirSync(projectRoot, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(content, 'bundles', 'base'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(content, 'bundles', 'ext'), { recursive: true });
+    // skill source dirs
+    for (const s of ['s-base', 's-ext']) {
+        fs_1.default.mkdirSync(path_1.default.join(content, 'skills', s), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(content, 'skills', s, 'SKILL.md'), `---\nname: ${s}\n---\n`);
+    }
+    // a workflow + agent source for `ext`
+    fs_1.default.mkdirSync(path_1.default.join(content, 'workflows'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(content, 'workflows', 'wf-ext.md'), '# wf');
+    fs_1.default.mkdirSync(path_1.default.join(content, 'agents'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(content, 'agents', 'ag-ext.md'), '# agent');
+    fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [
+            { name: 'base', source: './bundles/base', version: '1.0.0', scope: 'project' },
+            { name: 'ext', source: './bundles/ext', version: '1.0.0', scope: 'project' },
+        ],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(content, 'bundles', 'base', 'bundle.json'), JSON.stringify({
+        name: 'base', version: '1.0.0', description: 'Base', scope: 'project', dependsOn: [],
+        skills: ['s-base'], workflows: [], agents: [],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(content, 'bundles', 'ext', 'bundle.json'), JSON.stringify({
+        name: 'ext', version: '1.0.0', description: 'Ext', scope: 'project', dependsOn: ['base'],
+        skills: ['s-ext'], workflows: ['wf-ext'], agents: ['ag-ext'],
+    }));
+    return { content, projectRoot, bundles: (0, bundles_1.discoverBundles)(content) };
+}
+describe('installBundle', () => {
+    it('materializes the bundle closure as local symlinks (deps + own skills)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const result = (0, bundle_install_1.installBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        const skillsDir = path_1.default.join(projectRoot, '.claude', 'skills');
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 's-base'))).toBe(true); // from dep `base`
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 's-ext'))).toBe(true); // from `ext`
+        expect(fs_1.default.lstatSync(path_1.default.join(skillsDir, 's-ext')).isSymbolicLink()).toBe(true);
+        expect(result.installed.some((l) => l.includes('s-base'))).toBe(true);
+    });
+    it('installs supported artifact types and skips unsupported ones (claude-code workflows)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const result = (0, bundle_install_1.installBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        // claude-code has no workflow dir → wf-ext is skipped; agents are supported.
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'agents', 'ag-ext.md'))).toBe(true);
+        expect(result.skipped.some((l) => l.includes('wf-ext'))).toBe(true);
+    });
+    it('is idempotent: a second run leaves valid symlinks and does not throw', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const opts = {
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        };
+        (0, bundle_install_1.installBundle)(opts);
+        expect(() => (0, bundle_install_1.installBundle)(opts)).not.toThrow();
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-ext'))).toBe(true);
+    });
+    it('skips artifacts whose source is missing instead of throwing', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        fs_1.default.rmSync(path_1.default.join(content, 'skills', 's-base'), { recursive: true, force: true });
+        const result = (0, bundle_install_1.installBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        expect(result.skipped.some((l) => l.includes('s-base'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-ext'))).toBe(true);
+    });
+});
+describe('addBundle', () => {
+    it('records a project bundle installed locally as an extension + gitignores symlinks', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const result = (0, bundle_install_1.addBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        expect(result.recordedExtension).toBe('ext');
+        expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual(['ext']);
+        const gi = fs_1.default.readFileSync(path_1.default.join(projectRoot, '.gitignore'), 'utf-8');
+        expect(gi).toContain('.claude/skills/');
+    });
+    it('does not record the dependency bundle, only the named one', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        (0, bundle_install_1.addBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual(['ext']); // not ['base','ext']
+    });
+    it('is idempotent: adding the same bundle twice keeps one extension entry', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const opts = {
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        };
+        (0, bundle_install_1.addBundle)(opts);
+        (0, bundle_install_1.addBundle)(opts);
+        expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual(['ext']);
+    });
+    it('does not record extension when all sources are missing (nothing installed)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        fs_1.default.rmSync(path_1.default.join(content, 'skills', 's-ext'), { recursive: true, force: true });
+        fs_1.default.rmSync(path_1.default.join(content, 'skills', 's-base'), { recursive: true, force: true });
+        fs_1.default.rmSync(path_1.default.join(content, 'agents', 'ag-ext.md'), { force: true });
+        const result = (0, bundle_install_1.addBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        expect(result.recordedExtension).toBeNull();
+        expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual([]);
+    });
+    it('does not record extension when only dep sources are present (named bundle own artifacts missing)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        // Remove only ext's own sources; keep dep (base) sources intact.
+        fs_1.default.rmSync(path_1.default.join(content, 'skills', 's-ext'), { recursive: true, force: true });
+        fs_1.default.rmSync(path_1.default.join(content, 'agents', 'ag-ext.md'), { force: true });
+        const result = (0, bundle_install_1.addBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        expect(result.installed.some((l) => l.includes('s-base'))).toBe(true); // dep installed
+        expect(result.recordedExtension).toBeNull(); // ext not recorded
+        expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual([]);
+    });
+    it('respects explicit scopeOverride: local and still records the extension', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const result = (0, bundle_install_1.addBundle)({
+            bundleName: 'ext', bundles, agents: ['claude-code'],
+            method: 'symlink', projectRoot, contentDir: content,
+            scopeOverride: 'local',
+        });
+        expect(result.recordedExtension).toBe('ext');
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-ext'))).toBe(true);
+        expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual(['ext']);
+    });
+});
+describe('syncProfile', () => {
+    it('rematerializes symlinks for every extension listed in the profile', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        (0, profile_1.writeProfile)(projectRoot, { extensions: ['ext'] });
+        const result = (0, bundle_install_1.syncProfile)({
+            projectRoot, bundles, agents: ['claude-code'],
+            method: 'symlink', contentDir: content,
+        });
+        expect(result.extensions).toEqual(['ext']);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-ext'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-base'))).toBe(true);
+    });
+    it('is a no-op when the profile has no extensions', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        (0, profile_1.writeProfile)(projectRoot, { extensions: [] });
+        const result = (0, bundle_install_1.syncProfile)({
+            projectRoot, bundles, agents: ['claude-code'],
+            method: 'symlink', contentDir: content,
+        });
+        expect(result.extensions).toEqual([]);
+        expect(result.installed).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills'))).toBe(false);
+    });
+    it('skips and warns about extensions no longer in registry (stale entries)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        (0, profile_1.writeProfile)(projectRoot, { extensions: ['stale-bundle', 'ext'] });
+        const result = (0, bundle_install_1.syncProfile)({
+            projectRoot, bundles, agents: ['claude-code'],
+            method: 'symlink', contentDir: content,
+        });
+        expect(result.extensions).toEqual(['stale-bundle', 'ext']);
+        expect(result.skipped.some((l) => l.includes('stale-bundle'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-ext'))).toBe(true);
+    });
+});

package/dist/tests/core/bundles-multiroot.test.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/bundles-multiroot.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+function writeBundleRoot(root, bundleName, skillName) {
+    fs_1.default.mkdirSync(path_1.default.join(root, 'bundles', bundleName), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', skillName), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', skillName, 'SKILL.md'), `---\nname: ${skillName}\ndescription: d\n---\n`);
+    fs_1.default.writeFileSync(path_1.default.join(root, 'bundles', bundleName, 'bundle.json'), JSON.stringify({ name: bundleName, version: '1.0.0', scope: 'ambient', skills: [skillName] }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [{ name: bundleName, source: `./bundles/${bundleName}`, version: '1.0.0', scope: 'ambient' }],
+    }));
+}
+describe('bundles multi-root', () => {
+    let tmp;
+    let rootA;
+    let rootB;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bundles-'));
+        rootA = path_1.default.join(tmp, 'a');
+        rootB = path_1.default.join(tmp, 'b');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('discoverAllBundles merges bundles from all roots and stamps contentRoot', () => {
+        writeBundleRoot(rootA, 'dev-x', 'sx');
+        writeBundleRoot(rootB, 'personal-x', 'px');
+        const { discoverAllBundles } = require('../../src/core/bundles');
+        const all = discoverAllBundles([rootA, rootB]);
+        expect(all.map((b) => b.name).sort()).toEqual(['dev-x', 'personal-x']);
+        expect(all.find((b) => b.name === 'personal-x').contentRoot).toBe(rootB);
+    });
+    it('discoverAllBundles throws naming both sources on bundle name collision', () => {
+        writeBundleRoot(rootA, 'dup', 's1');
+        writeBundleRoot(rootB, 'dup', 's2');
+        const { discoverAllBundles } = require('../../src/core/bundles');
+        expect(() => discoverAllBundles([rootA, rootB])).toThrow(/dup/);
+        expect(() => discoverAllBundles([rootA, rootB])).toThrow(new RegExp(rootA.replace(/[/\\]/g, '.')));
+        expect(() => discoverAllBundles([rootA, rootB])).toThrow(new RegExp(rootB.replace(/[/\\]/g, '.')));
+    });
+    it('installBundle resolves artifacts from the bundle own contentRoot', () => {
+        writeBundleRoot(rootB, 'personal-x', 'px');
+        const { discoverAllBundles } = require('../../src/core/bundles');
+        const { installBundle } = require('../../src/core/bundle-install');
+        const bundles = discoverAllBundles([rootB]);
+        const projectRoot = path_1.default.join(tmp, 'proj');
+        fs_1.default.mkdirSync(projectRoot, { recursive: true });
+        const summary = installBundle({
+            bundleName: 'personal-x',
+            bundles,
+            agents: ['claude-code'],
+            method: 'copy',
+            projectRoot,
+            scopeOverride: 'local',
+        });
+        // the skill was copied FROM rootB (its own root), not from the default
+        expect(summary.installed.some((l) => l.startsWith('px'))).toBe(true);
+        expect(summary.skipped.some((l) => l.includes('source missing'))).toBe(false);
+    });
+});

package/dist/tests/core/bundles-overrides.test.js

@@ -0,0 +1,49 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+function writeBundleRoot(root, bundleName, skillName) {
+    fs_1.default.mkdirSync(path_1.default.join(root, 'bundles', bundleName), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', skillName), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', skillName, 'SKILL.md'), `---\nname: ${skillName}\ndescription: d\n---\n`);
+    fs_1.default.writeFileSync(path_1.default.join(root, 'bundles', bundleName, 'bundle.json'), JSON.stringify({ name: bundleName, version: '1.0.0', scope: 'ambient', skills: [skillName] }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [{ name: bundleName, source: `./bundles/${bundleName}`, version: '1.0.0', scope: 'ambient' }],
+    }));
+}
+describe('bundle override resolution', () => {
+    let tmp;
+    let rootA;
+    let rootB;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bnd-ovr-'));
+        rootA = path_1.default.join(tmp, 'a');
+        rootB = path_1.default.join(tmp, 'b');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('declared override: later root wins, contentRoot and overrode reflect it', () => {
+        writeBundleRoot(rootA, 'pack', 's1');
+        writeBundleRoot(rootB, 'pack', 's2');
+        fs_1.default.writeFileSync(path_1.default.join(rootB, 'awm-registry.json'), JSON.stringify({ overrides: ['pack'] }));
+        const { discoverAllBundles } = require('../../src/core/bundles');
+        const out = discoverAllBundles([rootA, rootB]);
+        expect(out).toHaveLength(1);
+        expect(out[0].contentRoot).toBe(rootB);
+        expect(out[0].overrode).toBe(rootA);
+    });
+    it('undeclared collision still throws naming both sources', () => {
+        writeBundleRoot(rootA, 'dup', 's1');
+        writeBundleRoot(rootB, 'dup', 's2');
+        const { discoverAllBundles } = require('../../src/core/bundles');
+        expect(() => discoverAllBundles([rootA, rootB])).toThrow(/dup/);
+        expect(() => discoverAllBundles([rootA, rootB])).toThrow(new RegExp(rootA.replace(/[/\\]/g, '.')));
+    });
+});

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

@@ -0,0 +1,96 @@
+"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 bundles_1 = require("../../src/core/bundles");
+function makeFixture() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bundles-'));
+    const content = path_1.default.join(root, 'registry');
+    fs_1.default.mkdirSync(path_1.default.join(content, 'bundles', 'dev'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(content, 'bundles', 'frontend'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [
+            { name: 'dev', source: './bundles/dev', version: '1.0.0', scope: 'baseline' },
+            { name: 'frontend', source: './bundles/frontend', version: '1.0.0', scope: 'project' },
+        ],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(content, 'bundles', 'dev', 'bundle.json'), JSON.stringify({
+        name: 'dev', version: '1.0.0', description: 'Dev core', scope: 'baseline', dependsOn: [],
+        skills: ['brainstorming', { name: 'architecture-advisor', onSignal: true }],
+        workflows: ['development-process'], agents: ['development-process'],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(content, 'bundles', 'frontend', 'bundle.json'), JSON.stringify({
+        name: 'frontend', version: '1.0.0', description: 'Frontend', scope: 'project', dependsOn: ['dev'],
+        skills: ['impeccable'], workflows: [], agents: [],
+    }));
+    return content;
+}
+describe('readCatalog', () => {
+    it('reads catalog entries', () => {
+        const content = makeFixture();
+        const entries = (0, bundles_1.readCatalog)(content);
+        expect(entries.map((e) => e.name).sort()).toEqual(['dev', 'frontend']);
+        expect(entries.find((e) => e.name === 'dev').scope).toBe('baseline');
+    });
+});
+describe('discoverBundles', () => {
+    it('loads each bundle and normalizes skill refs (string | object)', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        const dev = bundles.find((b) => b.name === 'dev');
+        expect(dev.skills).toEqual([
+            { name: 'brainstorming', onSignal: false },
+            { name: 'architecture-advisor', onSignal: true },
+        ]);
+        expect(dev.scope).toBe('baseline');
+        expect(dev.dependsOn).toEqual([]);
+    });
+    it('returns [] when catalog is missing', () => {
+        const empty = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-'));
+        expect((0, bundles_1.discoverBundles)(empty)).toEqual([]);
+    });
+});
+describe('resolveBundleSkills', () => {
+    it('follows dependsOn transitively and dedupes', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        const names = (0, bundles_1.resolveBundleSkills)('frontend', bundles);
+        expect(names.sort()).toEqual(['architecture-advisor', 'brainstorming', 'impeccable']);
+    });
+    it('returns own skills when no deps', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        expect((0, bundles_1.resolveBundleSkills)('dev', bundles).sort()).toEqual(['architecture-advisor', 'brainstorming']);
+    });
+});
+describe('defaultScopeForBundle', () => {
+    it('maps baseline and ambient to global, project to local', () => {
+        expect((0, bundles_1.defaultScopeForBundle)('baseline')).toBe('global');
+        expect((0, bundles_1.defaultScopeForBundle)('ambient')).toBe('global');
+        expect((0, bundles_1.defaultScopeForBundle)('project')).toBe('local');
+    });
+});
+describe('resolveBundleClosure', () => {
+    it('returns dependencies before the bundle, deduped, in deps-first order', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        const closure = (0, bundles_1.resolveBundleClosure)('frontend', bundles);
+        expect(closure.map((b) => b.name)).toEqual(['dev', 'frontend']);
+    });
+    it('returns just the bundle when it has no dependencies', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        const closure = (0, bundles_1.resolveBundleClosure)('dev', bundles);
+        expect(closure.map((b) => b.name)).toEqual(['dev']);
+    });
+    it('returns [] for an unknown bundle name', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        expect((0, bundles_1.resolveBundleClosure)('nope', bundles)).toEqual([]);
+    });
+});

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

@@ -0,0 +1,17 @@
+"use strict";
+describe('cliVersion / compareSemver', () => {
+    it('cliVersion devuelve la versión del package.json del CLI', () => {
+        const { cliVersion } = require('../../src/core/cli-version');
+        const pkg = require('../../package.json');
+        expect(cliVersion()).toBe(pkg.version);
+    });
+    it.each([
+        ['1.0.0', '1.0.0', 0],
+        ['2.0.0', '1.9.9', 1],
+        ['1.9.0', '1.10.0', -1], // orden numérico, no lexicográfico
+        ['1.0.1', '1.0.0', 1],
+    ])('compareSemver(%s, %s) → signo %i', (a, b, sign) => {
+        const { compareSemver } = require('../../src/core/versioning');
+        expect(Math.sign(compareSemver(a, b))).toBe(sign);
+    });
+});

package/dist/tests/core/context/materializer.test.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/context/materializer.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const materializer_1 = require("../../../src/core/context/materializer");
+const provider_1 = require("../../../src/core/context/provider");
+function ctxOf(markdown) {
+    return { markdown, sourceVersion: '1.0.0', contentHash: (0, provider_1.sha256)(markdown) };
+}
+describe('globalContextPath', () => {
+    it('points under AWM_HOME/context', () => {
+        expect((0, materializer_1.globalContextPath)()).toContain(path_1.default.join('context', 'awm-context.md'));
+    });
+});
+describe('materialize', () => {
+    it('writes the content and returns a ref with the matching hash', () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mat-'));
+        const abs = path_1.default.join(dir, 'awm-context.md');
+        const ctx = ctxOf('CONTENT-A');
+        const ref = (0, materializer_1.materialize)(ctx, abs, 'global');
+        expect(ref).toEqual({ absPath: abs, scope: 'global', contentHash: ctx.contentHash });
+        expect(fs_1.default.readFileSync(abs, 'utf-8')).toBe('CONTENT-A');
+    });
+    it('is a no-op when the on-disk hash already matches (mtime unchanged)', () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mat-'));
+        const abs = path_1.default.join(dir, 'awm-context.md');
+        const ctx = ctxOf('CONTENT-A');
+        (0, materializer_1.materialize)(ctx, abs, 'global');
+        const mtime1 = fs_1.default.statSync(abs).mtimeMs;
+        (0, materializer_1.materialize)(ctx, abs, 'global'); // same content
+        expect(fs_1.default.statSync(abs).mtimeMs).toBe(mtime1);
+    });
+    it('rewrites when the content changed', () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mat-'));
+        const abs = path_1.default.join(dir, 'awm-context.md');
+        (0, materializer_1.materialize)(ctxOf('CONTENT-A'), abs, 'global');
+        const ref = (0, materializer_1.materialize)(ctxOf('CONTENT-B'), abs, 'global');
+        expect(fs_1.default.readFileSync(abs, 'utf-8')).toBe('CONTENT-B');
+        expect(ref.contentHash).toBe((0, provider_1.sha256)('CONTENT-B'));
+    });
+});