agentic-workflow-manager 2.0.0

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

@@ -0,0 +1,66 @@
+"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/registries-seed.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('core/registries — seedBaselineRegistry + contentRoots sin base especial', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    let originalBaseRemote;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-seed-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        originalBaseRemote = process.env.AWM_BASE_REMOTE;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        delete process.env.AWM_BASE_REMOTE;
+        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;
+        if (originalBaseRemote === undefined)
+            delete process.env.AWM_BASE_REMOTE;
+        else
+            process.env.AWM_BASE_REMOTE = originalBaseRemote;
+    });
+    it('seedBaselineRegistry crea registries.json con baseline la primera vez', () => {
+        const m = require('../../src/core/registries');
+        expect(m.seedBaselineRegistry()).toBe(true);
+        expect(m.readRegistriesConfig()).toEqual([
+            { name: 'baseline', remote: require('../../src/core/registry').DEFAULT_REMOTE },
+        ]);
+    });
+    it('seedBaselineRegistry respeta AWM_BASE_REMOTE', () => {
+        process.env.AWM_BASE_REMOTE = '/tmp/mi-remote';
+        jest.resetModules();
+        const m = require('../../src/core/registries');
+        m.seedBaselineRegistry();
+        expect(m.readRegistriesConfig()[0].remote).toBe('/tmp/mi-remote');
+        delete process.env.AWM_BASE_REMOTE;
+    });
+    it('seedBaselineRegistry es no-op si registries.json ya existe (idempotente, respeta ediciones)', () => {
+        const m = require('../../src/core/registries');
+        m.writeRegistriesConfig([{ name: 'equipo', remote: 'x' }]);
+        expect(m.seedBaselineRegistry()).toBe(false);
+        expect(m.readRegistriesConfig()).toEqual([{ name: 'equipo', remote: 'x' }]);
+    });
+    it('contentRoots ya no incluye un root base especial', () => {
+        const m = require('../../src/core/registries');
+        m.writeRegistriesConfig([]);
+        expect(m.contentRoots()).toEqual([]);
+    });
+});

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

@@ -0,0 +1,205 @@
+"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/registries-sync.test.ts
+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 GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t -c tag.gpgSign=false ${cmd}`, { cwd, stdio: 'pipe' });
+/** Creates a git source repo with a skill, returns its path (serves as local remote). */
+function makeSourceRepo(base, skillName) {
+    const dir = path_1.default.join(base, `src-${skillName}`);
+    fs_1.default.mkdirSync(path_1.default.join(dir, 'skills', skillName), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'skills', skillName, 'SKILL.md'), `---\nname: ${skillName}\ndescription: test skill\n---\n# ${skillName}\n`);
+    GIT(dir, 'init -q');
+    GIT(dir, 'add -A');
+    GIT(dir, 'commit -qm init');
+    return dir;
+}
+describe('syncRegistries (git fixtures locales)', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regsync-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regsync-work-'));
+        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 });
+        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;
+    });
+    it('re-clones a configured registry missing on disk', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
+        const results = await m.syncRegistries();
+        expect(results).toEqual([{ name: 'personal', action: 'recloned', version: 'HEAD' }]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/personal/skills/alpha/SKILL.md'))).toBe(true);
+    });
+    it('pulls an existing clone and reports non-fatal errors per registry', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        m.writeRegistriesConfig([
+            { name: 'personal', remote: source },
+            { name: 'broken', remote: path_1.default.join(tmpWork, 'does-not-exist') },
+        ]);
+        await m.syncRegistries(); // first pass: clones 'personal', fails 'broken'
+        // advance the remote
+        fs_1.default.writeFileSync(path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: v2\n---\n');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm v2');
+        const results = await m.syncRegistries();
+        expect(results[0]).toEqual({ name: 'personal', action: 'pulled', version: 'HEAD' });
+        expect(results[1].name).toBe('broken');
+        expect(results[1].action).toBe('error');
+        const synced = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/registries/personal/skills/alpha/SKILL.md'), 'utf-8');
+        expect(synced).toContain('v2');
+    });
+    it('registry con tags queda en el último tag y reporta la versión', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        GIT(source, 'tag v1.0.0');
+        // commit post-tag: HEAD va más allá del release
+        fs_1.default.writeFileSync(path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: unreleased\n---\n');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm unreleased');
+        m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
+        const results = await m.syncRegistries();
+        expect(results).toEqual([{ name: 'personal', action: 'recloned', version: 'v1.0.0' }]);
+        const synced = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/registries/personal/skills/alpha/SKILL.md'), 'utf-8');
+        expect(synced).toContain('test skill'); // contenido del tag, no del HEAD
+    });
+    it('F2 regression: clone fresco limpiado si pin inexistente falla post-clone', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        GIT(source, 'tag v1.0.0');
+        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' } }));
+        const results = await m.syncRegistries();
+        expect(results[0].action).toBe('error');
+        // El dir no debe quedar en disco tras el fallo
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/personal'))).toBe(false);
+    });
+    it('pin por nombre en preferences gana sobre el último tag', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        GIT(source, 'tag v1.0.0');
+        fs_1.default.writeFileSync(path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: v2\n---\n');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm v2');
+        GIT(source, 'tag v1.1.0');
+        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' } }));
+        const results = await m.syncRegistries();
+        expect(results).toEqual([{ name: 'personal', action: 'recloned', version: 'v1.0.0' }]);
+    });
+    it('baseline sembrado se sincroniza por el mismo loop que cualquier registry', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        GIT(source, 'tag v1.0.0');
+        process.env.AWM_BASE_REMOTE = source;
+        m.seedBaselineRegistry();
+        delete process.env.AWM_BASE_REMOTE;
+        const results = await m.syncRegistries();
+        expect(results).toEqual([{ name: 'baseline', action: 'recloned', version: 'v1.0.0' }]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/baseline/skills/alpha/SKILL.md'))).toBe(true);
+    });
+    it('verifyMinCliVersions reporta registries que exigen CLI más nuevo', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        fs_1.default.writeFileSync(path_1.default.join(source, 'awm-registry.json'), JSON.stringify({ minCliVersion: '99.0.0' }));
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm manifest');
+        m.writeRegistriesConfig([{ name: 'exigente', remote: source }]);
+        await m.syncRegistries();
+        const failures = m.verifyMinCliVersions();
+        expect(failures).toEqual([{ name: 'exigente', min: '99.0.0' }]);
+    });
+    it('verifyMinCliVersions ignora registries sin campo o ausentes en disco', () => {
+        const m = require('../../src/core/registries');
+        m.writeRegistriesConfig([{ name: 'fantasma', remote: '/no/existe' }]);
+        expect(m.verifyMinCliVersions()).toEqual([]);
+    });
+    it('transición tag→tag: clone existente en v1.0.0 avanza a v1.1.0 tras nuevo release', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        GIT(source, 'tag v1.0.0');
+        m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
+        // primera sync: queda en v1.0.0
+        const r1 = await m.syncRegistries();
+        expect(r1).toEqual([{ name: 'personal', action: 'recloned', version: 'v1.0.0' }]);
+        // nueva release en el remote
+        fs_1.default.writeFileSync(path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: v2\n---\n');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm v1.1.0');
+        GIT(source, 'tag v1.1.0');
+        // segunda sync: avanza al nuevo tag
+        const r2 = await m.syncRegistries();
+        expect(r2).toEqual([{ name: 'personal', action: 'pulled', version: 'v1.1.0' }]);
+        const content = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/registries/personal/skills/alpha/SKILL.md'), 'utf-8');
+        expect(content).toContain('v2');
+    });
+    it('rollback tag→tag: clone en v1.1.0 retrocede a v1.0.0 al establecer pin', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        GIT(source, 'tag v1.0.0');
+        fs_1.default.writeFileSync(path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: v2\n---\n');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm v1.1.0');
+        GIT(source, 'tag v1.1.0');
+        m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
+        // primera sync sin pin: queda en v1.1.0
+        const r1 = await m.syncRegistries();
+        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' } }));
+        // 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' }]);
+        const content = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/registries/personal/skills/alpha/SKILL.md'), 'utf-8');
+        expect(content).toContain('test skill'); // contenido original del tag v1.0.0
+    });
+    it('canal dev: preferences.channel=dev sigue HEAD y recibe commits nuevos', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        GIT(source, 'tag v1.0.0');
+        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' }));
+        // 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' }]);
+        // nuevo commit en el remote (post-tag, no release)
+        fs_1.default.writeFileSync(path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: head-2\n---\n');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm head-2');
+        // segunda sync: recibe el nuevo commit
+        const r2 = await m.syncRegistries();
+        expect(r2).toEqual([{ name: 'personal', action: 'pulled', version: 'HEAD' }]);
+        const content = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/registries/personal/skills/alpha/SKILL.md'), 'utf-8');
+        expect(content).toContain('head-2');
+    });
+});

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

@@ -0,0 +1,91 @@
+"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/registries.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('core/registries', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-registries-'));
+        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;
+    });
+    function load() {
+        return require('../../src/core/registries');
+    }
+    it('readRegistriesConfig returns [] when the config file does not exist', () => {
+        expect(load().readRegistriesConfig()).toEqual([]);
+    });
+    it('write + read round-trips entries', () => {
+        const m = load();
+        m.writeRegistriesConfig([{ name: 'personal', remote: 'git@github.com:x/y.git' }]);
+        expect(m.readRegistriesConfig()).toEqual([{ name: 'personal', remote: 'git@github.com:x/y.git' }]);
+    });
+    it('readRegistriesConfig throws an explicit error naming the path on corrupt JSON', () => {
+        const m = load();
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), '{not json');
+        expect(() => m.readRegistriesConfig()).toThrow(/registries\.json/);
+    });
+    it('readRegistriesConfig throws on non-array or malformed entries', () => {
+        const m = load();
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), JSON.stringify({ foo: 1 }));
+        expect(() => m.readRegistriesConfig()).toThrow(/expected a JSON array/);
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), JSON.stringify([{ name: 'x' }]));
+        expect(() => m.readRegistriesConfig()).toThrow(/malformed entry/);
+    });
+    it('readRegistriesConfig rejects single-dot name to prevent path traversal', () => {
+        const m = load();
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), JSON.stringify([{ name: '.', remote: 'r' }]));
+        expect(() => m.readRegistriesConfig()).toThrow(/path traversal/);
+    });
+    it('listRegistries derives contentRoot under ~/.awm/registries/<name>', () => {
+        const m = load();
+        m.writeRegistriesConfig([{ name: 'personal', remote: 'r' }]);
+        expect(m.listRegistries()).toEqual([
+            { name: 'personal', remote: 'r', contentRoot: path_1.default.join(tmpHome, '.awm', 'registries', 'personal') },
+        ]);
+    });
+    it('contentRoots includes only configured registries present on disk', () => {
+        const m = load();
+        // 'present' existe en disco, 'ghost' no
+        const present = path_1.default.join(tmpHome, '.awm', 'registries', 'present');
+        fs_1.default.mkdirSync(present, { recursive: true });
+        m.writeRegistriesConfig([{ name: 'present', remote: 'r1' }, { name: 'ghost', remote: 'r2' }]);
+        expect(m.contentRoots()).toEqual([present]);
+    });
+    it('contentRoots returns [] when no registries are configured', () => {
+        const m = load();
+        expect(m.contentRoots()).toEqual([]);
+    });
+    it('validateRegistryLayout requires at least one content dir at the root', () => {
+        const m = load();
+        const root = path_1.default.join(tmpHome, 'somerepo');
+        fs_1.default.mkdirSync(root, { recursive: true });
+        expect(m.validateRegistryLayout(root)).toBe(false);
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills'));
+        expect(m.validateRegistryLayout(root)).toBe(true);
+    });
+});

package/dist/tests/core/registry-manifest.test.js

@@ -0,0 +1,95 @@
+"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/registry-manifest.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('registry manifest (awm-registry.json)', () => {
+    let tmpHome;
+    let tmpWork;
+    const origHome = process.env.HOME;
+    const origAwmHome = process.env.AWM_HOME;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-work-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        process.env.HOME = origHome;
+        if (origAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = origAwmHome;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+    });
+    function load() {
+        return require('../../src/core/registries');
+    }
+    it('returns empty overrides when manifest file is absent', () => {
+        const { readRegistryManifest } = load();
+        const m = readRegistryManifest(tmpWork);
+        expect(m.overrides.size).toBe(0);
+    });
+    it('parses a valid manifest into a Set of names', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), JSON.stringify({ overrides: ['brainstorming', 'writing-plans'] }));
+        const { readRegistryManifest } = load();
+        const m = readRegistryManifest(tmpWork);
+        expect(m.overrides.has('brainstorming')).toBe(true);
+        expect(m.overrides.has('writing-plans')).toBe(true);
+        expect(m.overrides.size).toBe(2);
+    });
+    it('treats a manifest without "overrides" key as empty', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), JSON.stringify({}));
+        const { readRegistryManifest } = load();
+        expect(readRegistryManifest(tmpWork).overrides.size).toBe(0);
+    });
+    it('throws with the file path on corrupt JSON — never silently empty', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), '{nope');
+        const { readRegistryManifest } = load();
+        expect(() => readRegistryManifest(tmpWork)).toThrow(/awm-registry\.json/);
+    });
+    it('throws when overrides is not an array of strings', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), JSON.stringify({ overrides: 'brainstorming' }));
+        const { readRegistryManifest } = load();
+        expect(() => readRegistryManifest(tmpWork)).toThrow(/array of strings/);
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), JSON.stringify({ overrides: [42] }));
+        jest.resetModules();
+        expect(() => load().readRegistryManifest(tmpWork)).toThrow(/array of strings/);
+    });
+    it.each(['', '.', '..', 'a/b', 'a\\b', '../up'])('rejects override name %j (path traversal guard)', (bad) => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), JSON.stringify({ overrides: [bad] }));
+        const { readRegistryManifest } = load();
+        expect(() => readRegistryManifest(tmpWork)).toThrow(/path traversal/);
+    });
+    it('registryNameForPath maps configured registries and returns null for unknown paths', () => {
+        const m = load();
+        const regPath = path_1.default.join(m.REGISTRIES_DIR, 'team-acme', 'skills', 'x');
+        expect(m.registryNameForPath(regPath)).toBe('team-acme');
+        expect(m.registryNameForPath('/somewhere/else')).toBeNull();
+    });
+    // minCliVersion tests (WS-4)
+    function writeManifest(data) {
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), JSON.stringify(data));
+    }
+    it('minCliVersion válido se expone normalizado (acepta prefijo v)', () => {
+        writeManifest({ minCliVersion: 'v2.1.0' });
+        const { readRegistryManifest } = load();
+        expect(readRegistryManifest(tmpWork).minCliVersion).toBe('2.1.0');
+    });
+    it('minCliVersion ausente → undefined', () => {
+        writeManifest({ overrides: [] });
+        const { readRegistryManifest } = load();
+        expect(readRegistryManifest(tmpWork).minCliVersion).toBeUndefined();
+    });
+    it.each([['banana'], ['2.1'], [2], [null]])('minCliVersion malformado %p → error explícito', (bad) => {
+        writeManifest({ minCliVersion: bad });
+        const { readRegistryManifest } = load();
+        expect(() => readRegistryManifest(tmpWork)).toThrow(/minCliVersion/);
+    });
+});

package/dist/tests/core/registry-versioned-sync.test.js

@@ -0,0 +1,113 @@
+"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/registry-versioned-sync.test.ts
+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 GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t -c tag.gpgSign=false ${cmd}`, { cwd, stdio: 'pipe' });
+function makeTaggedRepo(base, name, versions) {
+    const dir = path_1.default.join(base, name);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    GIT(dir, 'init -q -b main');
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'VERSION'), 'init');
+    GIT(dir, 'add -A');
+    GIT(dir, 'commit -qm init');
+    for (const v of versions) {
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'VERSION'), v);
+        GIT(dir, 'add -A');
+        GIT(dir, `commit -qm ${v}`);
+        GIT(dir, `tag v${v}`);
+    }
+    return dir;
+}
+function addRelease(source, version) {
+    fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), version);
+    GIT(source, 'add -A');
+    GIT(source, `commit -qm ${version}`);
+    GIT(source, `tag v${version}`);
+}
+describe('syncRegistry versionado (fixtures git locales)', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regver-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regver-work-'));
+        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 });
+        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;
+    });
+    const registryVersionFile = () => path_1.default.join(process.env.AWM_HOME, 'cli-source/VERSION');
+    it('clone fresco queda checkouteado en el último tag (no en HEAD)', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+        // commit post-tag: HEAD del remote va más allá del último release
+        fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), 'unreleased');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm unreleased');
+        const { syncRegistry } = require('../../src/core/registry');
+        const resolved = await syncRegistry(source, { channel: 'stable' });
+        expect(resolved).toEqual({ kind: 'tag', ref: 'v1.0.0', version: '1.0.0' });
+        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.0.0');
+    });
+    it('clone existente transiciona al tag nuevo tras un release en el remote', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+        const { syncRegistry } = require('../../src/core/registry');
+        await syncRegistry(source, { channel: 'stable' });
+        addRelease(source, '1.1.0');
+        const resolved = await syncRegistry(source, { channel: 'stable' });
+        expect(resolved).toEqual({ kind: 'tag', ref: 'v1.1.0', version: '1.1.0' });
+        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.1.0');
+    });
+    it('rollback: pin a un tag anterior vuelve el contenido a esa versión', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0', '1.1.0']);
+        const { syncRegistry } = require('../../src/core/registry');
+        await syncRegistry(source, { channel: 'stable' });
+        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.1.0');
+        const resolved = await syncRegistry(source, { pin: '1.0.0', channel: 'stable' });
+        expect(resolved).toEqual({ kind: 'tag', ref: 'v1.0.0', version: '1.0.0' });
+        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.0.0');
+    });
+    it('canal dev sigue HEAD del branch y recibe commits nuevos', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+        const { syncRegistry } = require('../../src/core/registry');
+        const first = await syncRegistry(source, { channel: 'dev' });
+        expect(first).toEqual({ kind: 'head', ref: 'main' });
+        fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), 'head-2');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm head-2');
+        await syncRegistry(source, { channel: 'dev' });
+        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('head-2');
+    });
+    it('repo sin tags en canal stable → head-fallback y sigue HEAD', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', []);
+        const { syncRegistry } = require('../../src/core/registry');
+        const resolved = await syncRegistry(source, { channel: 'stable' });
+        expect(resolved).toEqual({ kind: 'head-fallback', ref: 'main' });
+        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('init');
+    });
+    it('sin opts (callers legacy) → comportamiento stable por default', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['2.0.0']);
+        const { syncRegistry } = require('../../src/core/registry');
+        const resolved = await syncRegistry(source);
+        expect(resolved).toEqual({ kind: 'tag', ref: 'v2.0.0', version: '2.0.0' });
+    });
+});

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+jest.mock('child_process');
+const mockSpawnSync = child_process_1.spawnSync;
+describe('buildCli', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('returns success when npm run build exits 0', () => {
+        mockSpawnSync.mockReturnValue({ status: 0, stderr: Buffer.from(''), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
+        const { buildCli } = require('../../src/core/registry');
+        const result = buildCli('/fake/cli');
+        expect(result).toEqual({ success: true });
+        expect(mockSpawnSync).toHaveBeenCalledWith('npm', ['run', 'build'], expect.objectContaining({ cwd: '/fake/cli', shell: true }));
+    });
+    it('returns failure with error message when build exits non-zero', () => {
+        mockSpawnSync.mockReturnValue({ status: 1, stderr: Buffer.from('tsc error: Type mismatch'), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
+        const { buildCli } = require('../../src/core/registry');
+        const result = buildCli('/fake/cli');
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('tsc error');
+    });
+    it('returns failure with stdout message when tsc writes errors to stdout', () => {
+        mockSpawnSync.mockReturnValue({ status: 2, stderr: Buffer.from(''), stdout: Buffer.from('error TS2322: Type mismatch'), pid: 1, output: [], signal: null });
+        const { buildCli } = require('../../src/core/registry');
+        const result = buildCli('/fake/cli');
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('TS2322');
+    });
+    it('returns failure when spawnSync throws unexpectedly', () => {
+        mockSpawnSync.mockImplementation(() => { throw new Error('unexpected error'); });
+        const { buildCli } = require('../../src/core/registry');
+        const result = buildCli('/fake/cli');
+        expect(result.success).toBe(false);
+        expect(result.error).toBe('unexpected error');
+    });
+    it('returns failure when npm is not found (shell returns status 127)', () => {
+        mockSpawnSync.mockReturnValue({ status: 127, stderr: Buffer.from('/bin/sh: npm: not found'), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
+        const { buildCli } = require('../../src/core/registry');
+        const result = buildCli('/fake/cli');
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('not found');
+    });
+    it('uses REGISTRY_DIR/cli as default cwd', () => {
+        mockSpawnSync.mockReturnValue({ status: 0, stderr: Buffer.from(''), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
+        const { buildCli, REGISTRY_DIR } = require('../../src/core/registry');
+        buildCli();
+        expect(mockSpawnSync).toHaveBeenCalledWith('npm', ['run', 'build'], expect.objectContaining({ cwd: `${REGISTRY_DIR}/cli` }));
+    });
+});