agentic-workflow-manager 2.0.0

package/dist/tests/core/skill-integrity.test.js

@@ -0,0 +1,126 @@
+"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 skill_integrity_1 = require("../../src/core/skill-integrity");
+describe('skill-integrity multi-root', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-integrity-'));
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('repairGlobalSkills re-links a dangling symlink to the FIRST root that has the skill', () => {
+        const skillsDir = path_1.default.join(tmp, 'installed');
+        const rootA = path_1.default.join(tmp, 'base');
+        const rootB = path_1.default.join(tmp, 'personal');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(rootB, 'skills', 'mine'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(rootB, 'skills', 'mine', 'SKILL.md'), '---\nname: mine\n---\n');
+        // dangling symlink: points to a deleted target
+        fs_1.default.symlinkSync(path_1.default.join(tmp, 'gone', 'mine'), path_1.default.join(skillsDir, 'mine'), 'dir');
+        const { repairGlobalSkills: repair } = require('../../src/core/skill-integrity');
+        const r = repair(skillsDir, [rootA, rootB]);
+        expect(r.relinked).toEqual(['mine']);
+        expect(fs_1.default.realpathSync(path_1.default.join(skillsDir, 'mine'))).toBe(fs_1.default.realpathSync(path_1.default.join(rootB, 'skills', 'mine')));
+    });
+    it('classifyGlobalSkills marks dead when NO root has the skill', () => {
+        const skillsDir = path_1.default.join(tmp, 'installed');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        fs_1.default.symlinkSync(path_1.default.join(tmp, 'gone', 'nope'), path_1.default.join(skillsDir, 'nope'), 'dir');
+        const { classifyGlobalSkills: classify } = require('../../src/core/skill-integrity');
+        const c = classify(skillsDir, [path_1.default.join(tmp, 'base')]);
+        expect(c.dead).toEqual(['nope']);
+    });
+});
+function setup() {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-integrity-'));
+    const skillsDir = path_1.default.join(tmp, 'claude-skills');
+    const registryContentDir = path_1.default.join(tmp, 'registry');
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(registryContentDir, 'skills'), { recursive: true });
+    return { skillsDir, registryContentDir };
+}
+function makeRegistrySkill(registryContentDir, name) {
+    const dir = path_1.default.join(registryContentDir, 'skills', name);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), `# ${name}\n`);
+    return dir;
+}
+describe('classifyGlobalSkills', () => {
+    it('classifies valid / repairable / dead', () => {
+        const { skillsDir, registryContentDir } = setup();
+        // valid: symlink a una skill que existe en el registry
+        const okTarget = makeRegistrySkill(registryContentDir, 'alpha');
+        fs_1.default.symlinkSync(okTarget, path_1.default.join(skillsDir, 'alpha'), 'dir');
+        // repairable: symlink colgante, pero la skill SÍ existe en el registry
+        makeRegistrySkill(registryContentDir, 'beta');
+        fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/beta'), path_1.default.join(skillsDir, 'beta'), 'dir');
+        // dead: symlink colgante y la skill NO existe en el registry
+        fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/gamma'), path_1.default.join(skillsDir, 'gamma'), 'dir');
+        const result = (0, skill_integrity_1.classifyGlobalSkills)(skillsDir, [registryContentDir]);
+        expect(result.valid).toEqual(['alpha']);
+        expect(result.repairable).toEqual(['beta']);
+        expect(result.dead).toEqual(['gamma']);
+    });
+    it('returns empty arrays when the skills dir does not exist', () => {
+        const result = (0, skill_integrity_1.classifyGlobalSkills)('/nonexistent/dir', ['/also/nonexistent']);
+        expect(result).toEqual({ valid: [], repairable: [], dead: [] });
+    });
+});
+describe('reconcileAllSkillLinks (#4 — awm update, all providers)', () => {
+    it('repairs every provider dir that exists and skips absent ones', () => {
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-home-'));
+        const prevHome = process.env.HOME;
+        process.env.HOME = home;
+        try {
+            jest.resetModules();
+            const { reconcileAllSkillLinks } = require('../../src/core/skill-integrity');
+            // OpenCode dir exists with a dead orphan; Claude dir does NOT exist.
+            const ocSkills = path_1.default.join(home, '.agents/skills');
+            fs_1.default.mkdirSync(ocSkills, { recursive: true });
+            fs_1.default.symlinkSync(path_1.default.join(home, 'no-such-target'), path_1.default.join(ocSkills, 'ghost'), 'dir');
+            const res = reconcileAllSkillLinks([path_1.default.join(home, 'no-registry')]);
+            const oc = res.find((r) => r.agent === 'opencode');
+            const cc = res.find((r) => r.agent === 'claude-code');
+            expect(oc).toBeTruthy();
+            expect(oc.result.pruned).toContain('ghost');
+            expect(cc).toBeFalsy(); // claude dir absent → not in results
+        }
+        finally {
+            process.env.HOME = prevHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
+});
+describe('repairGlobalSkills', () => {
+    it('re-links repairable to registry content dir and prunes dead; valid untouched; idempotent', () => {
+        const { skillsDir, registryContentDir } = setup();
+        const okTarget = makeRegistrySkill(registryContentDir, 'alpha');
+        fs_1.default.symlinkSync(okTarget, path_1.default.join(skillsDir, 'alpha'), 'dir');
+        makeRegistrySkill(registryContentDir, 'beta');
+        fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/beta'), path_1.default.join(skillsDir, 'beta'), 'dir');
+        fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/gamma'), path_1.default.join(skillsDir, 'gamma'), 'dir');
+        const r1 = (0, skill_integrity_1.repairGlobalSkills)(skillsDir, [registryContentDir]);
+        expect(r1.relinked).toEqual(['beta']);
+        expect(r1.pruned).toEqual(['gamma']);
+        // beta ahora apunta al registry content dir y resuelve
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 'beta'))).toBe(true);
+        expect(fs_1.default.realpathSync(path_1.default.join(skillsDir, 'beta')))
+            .toBe(fs_1.default.realpathSync(path_1.default.join(registryContentDir, 'skills', 'beta')));
+        // gamma podado
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 'gamma'))).toBe(false);
+        // alpha intacto
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 'alpha'))).toBe(true);
+        // idempotente: segunda corrida no cambia nada
+        const r2 = (0, skill_integrity_1.repairGlobalSkills)(skillsDir, [registryContentDir]);
+        expect(r2.relinked).toEqual([]);
+        expect(r2.pruned).toEqual([]);
+    });
+});

package/dist/tests/core/story-map-parser.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const story_map_parser_1 = require("../../src/core/story-map-parser");
+const SAMPLE_MARKDOWN = `---
+project: Portal B2B
+---
+
+# Story Map — Portal B2B
+
+## Goal
+> Permitir a proveedores gestionar su relación con Cencosud
+
+## Personas
+
+### Proveedor
+- **Rol:** Externo
+
+## Backbone
+
+### 🟡 Acceder al portal
+
+#### 🔵 Task: Iniciar sesión
+- **[MVP]** Como proveedor, quiero iniciar sesión con mi usuario y contraseña
+- **[Release 2]** Como proveedor, quiero autenticarme con SSO
+
+#### 🔵 Task: Seleccionar país y UN
+- **[MVP]** Como proveedor, quiero seleccionar mi país al ingresar
+
+### 🟡 Consultar mis datos
+
+#### 🔵 Task: Ver dashboard
+- **[MVP]** Como proveedor, quiero ver mis indicadores principales
+
+## Release Summary
+
+| Release | Stories |
+|---------|---------|
+| MVP | 3 |
+
+## Changelog
+
+- [2026-03-31] Sesión 1
+`;
+const MARKDOWN_WITH_FRAME_ID = `---
+project: Portal B2B
+miro_frame_id: "existing-id"
+---
+
+# Story Map — Portal B2B
+`;
+describe('parseStoryMap', () => {
+    it('extracts project name from frontmatter', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(SAMPLE_MARKDOWN);
+        expect(result.project).toBe('Portal B2B');
+    });
+    it('extracts goal text stripping the > prefix', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(SAMPLE_MARKDOWN);
+        expect(result.goal).toBe('Permitir a proveedores gestionar su relación con Cencosud');
+    });
+    it('returns undefined miro_frame_id when not in frontmatter', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(SAMPLE_MARKDOWN);
+        expect(result.miro_frame_id).toBeUndefined();
+    });
+    it('extracts miro_frame_id from frontmatter when present', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(MARKDOWN_WITH_FRAME_ID);
+        expect(result.miro_frame_id).toBe('existing-id');
+    });
+    it('extracts activities in order', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(SAMPLE_MARKDOWN);
+        expect(result.activities).toHaveLength(2);
+        expect(result.activities[0].title).toBe('Acceder al portal');
+        expect(result.activities[1].title).toBe('Consultar mis datos');
+    });
+    it('extracts tasks under each activity', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(SAMPLE_MARKDOWN);
+        expect(result.activities[0].tasks).toHaveLength(2);
+        expect(result.activities[0].tasks[0].title).toBe('Iniciar sesión');
+        expect(result.activities[0].tasks[1].title).toBe('Seleccionar país y UN');
+    });
+    it('extracts stories with their release labels', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(SAMPLE_MARKDOWN);
+        const stories = result.activities[0].tasks[0].stories;
+        expect(stories).toHaveLength(2);
+        expect(stories[0]).toEqual({ release: 'MVP', title: 'Como proveedor, quiero iniciar sesión con mi usuario y contraseña' });
+        expect(stories[1]).toEqual({ release: 'Release 2', title: 'Como proveedor, quiero autenticarme con SSO' });
+    });
+    it('ignores content outside Backbone section', () => {
+        const result = (0, story_map_parser_1.parseStoryMap)(SAMPLE_MARKDOWN);
+        expect(result.activities.every(a => !a.title.includes('Release') && !a.title.includes('Changelog'))).toBe(true);
+    });
+    it('falls back to title when project is absent from frontmatter', () => {
+        const content = `---
+goal: Some goal
+---
+
+# Story Map — Derived From Title
+
+## Goal
+> Some goal
+`;
+        const result = (0, story_map_parser_1.parseStoryMap)(content);
+        expect(result.project).toBe('Derived From Title');
+    });
+    it('falls back to Unknown when project and title are both absent', () => {
+        const content = `---
+goal: Some goal
+---
+
+## Goal
+> Some goal
+`;
+        const result = (0, story_map_parser_1.parseStoryMap)(content);
+        expect(result.project).toBe('Unknown');
+    });
+});
+describe('updateMiroFrameId', () => {
+    it('adds miro_frame_id to existing frontmatter and result parses correctly', () => {
+        const result = (0, story_map_parser_1.updateMiroFrameId)(SAMPLE_MARKDOWN, 'new-frame-123');
+        expect(result).toContain('miro_frame_id: "new-frame-123"');
+        // Round-trip: the updated content should parse back to a valid StoryMap with the new id
+        const parsed = (0, story_map_parser_1.parseStoryMap)(result);
+        expect(parsed.miro_frame_id).toBe('new-frame-123');
+        expect(parsed.project).toBe('Portal B2B');
+        expect(parsed.activities).toHaveLength(2);
+    });
+    it('replaces existing miro_frame_id', () => {
+        const result = (0, story_map_parser_1.updateMiroFrameId)(MARKDOWN_WITH_FRAME_ID, 'new-frame-456');
+        expect(result).toContain('miro_frame_id: "new-frame-456"');
+        expect(result).not.toContain('existing-id');
+    });
+    it('preserves the rest of the frontmatter and body', () => {
+        const result = (0, story_map_parser_1.updateMiroFrameId)(SAMPLE_MARKDOWN, 'new-frame-123');
+        expect(result).toContain('project: Portal B2B');
+        expect(result).toContain('# Story Map — Portal B2B');
+    });
+});

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

@@ -0,0 +1,97 @@
+"use strict";
+// cli/tests/core/sync-gates.test.ts
+//
+// Gate por unidad para verifyMinCliVersions (WS-4).
+// Patrón replicado de profile-pins.test.ts: tmpHome aislado, jest.resetModules(), require tardío.
+// El exit-1 del handler NO se testea aquí — el gate de pins (B1) estableció el patrón
+// de testear la unidad pura; los handlers se testean por integración.
+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 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 makeRegistryWithManifest(base, name, manifest) {
+    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, 'awm-registry.json'), JSON.stringify(manifest));
+    GIT(dir, 'add -A');
+    GIT(dir, 'commit -qm init');
+    return dir;
+}
+describe('verifyMinCliVersions (gate de awm sync / awm update)', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-minCli-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-minCli-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('CLI igual a minCliVersion → sin failures', async () => {
+        const source = makeRegistryWithManifest(tmpWork, 'src', { minCliVersion: '2.0.0' });
+        const { writeRegistriesConfig, syncRegistries, verifyMinCliVersions } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries();
+        // Inyectamos la versión actual como igual al mínimo requerido
+        expect(verifyMinCliVersions('2.0.0')).toEqual([]);
+    });
+    it('CLI mayor que minCliVersion → sin failures', async () => {
+        const source = makeRegistryWithManifest(tmpWork, 'src', { minCliVersion: '2.0.0' });
+        const { writeRegistriesConfig, syncRegistries, verifyMinCliVersions } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries();
+        expect(verifyMinCliVersions('2.1.0')).toEqual([]);
+    });
+    it('CLI menor que minCliVersion → 1 failure con name y min', async () => {
+        const source = makeRegistryWithManifest(tmpWork, 'src', { minCliVersion: '2.0.0' });
+        const { writeRegistriesConfig, syncRegistries, verifyMinCliVersions } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries();
+        const failures = verifyMinCliVersions('1.0.0');
+        expect(failures).toHaveLength(1);
+        expect(failures[0]).toMatchObject({ name: 'baseline', min: '2.0.0' });
+    });
+    it('registry sin minCliVersion → sin failures independientemente de la versión del CLI', async () => {
+        const source = makeRegistryWithManifest(tmpWork, 'src', { overrides: [] });
+        const { writeRegistriesConfig, syncRegistries, verifyMinCliVersions } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries();
+        expect(verifyMinCliVersions('0.0.1')).toEqual([]);
+    });
+    it('múltiples registries: solo el que falla genera un failure', async () => {
+        const src1 = makeRegistryWithManifest(tmpWork, 'r1', { minCliVersion: '2.0.0' });
+        const src2 = makeRegistryWithManifest(tmpWork, 'r2', { minCliVersion: '1.0.0' });
+        const { writeRegistriesConfig, syncRegistries, verifyMinCliVersions } = require('../../src/core/registries');
+        writeRegistriesConfig([
+            { name: 'alpha', remote: src1 },
+            { name: 'beta', remote: src2 },
+        ]);
+        await syncRegistries();
+        // CLI 1.5.0: cumple con beta (>=1.0.0) pero NO con alpha (>=2.0.0)
+        const failures = verifyMinCliVersions('1.5.0');
+        expect(failures).toHaveLength(1);
+        expect(failures[0]).toMatchObject({ name: 'alpha', min: '2.0.0' });
+    });
+});

package/dist/tests/core/update-check.test.js

@@ -0,0 +1,106 @@
+"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/update-check.test.ts  (dual-tmpdir estándar)
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+// @clack/prompts ships as ESM; mock it so Jest (CommonJS mode) can load update-check
+jest.mock('@clack/prompts', () => ({
+    confirm: jest.fn(),
+    isCancel: jest.fn(),
+}));
+describe('update-check', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    let originalNoUpdate;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-uc-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-uc-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        originalNoUpdate = process.env.AWM_NO_UPDATE_CHECK;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        delete process.env.AWM_NO_UPDATE_CHECK;
+        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;
+        if (originalNoUpdate === undefined)
+            delete process.env.AWM_NO_UPDATE_CHECK;
+        else
+            process.env.AWM_NO_UPDATE_CHECK = originalNoUpdate;
+        jest.restoreAllMocks();
+    });
+    it('fetchLatestVersion devuelve la versión del registry npm', async () => {
+        const { fetchLatestVersion } = require('../../src/core/update-check');
+        const fakeFetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ version: '2.3.0' }) });
+        await expect(fetchLatestVersion(fakeFetch)).resolves.toBe('2.3.0');
+    });
+    it('fetchLatestVersion sin red → null en silencio', async () => {
+        const { fetchLatestVersion } = require('../../src/core/update-check');
+        const fakeFetch = jest.fn().mockRejectedValue(new Error('offline'));
+        await expect(fetchLatestVersion(fakeFetch)).resolves.toBeNull();
+    });
+    it('maybeNotifyUpdate avisa si el cache trae versión más nueva y NO refresca cache fresco', () => {
+        const m = require('../../src/core/update-check');
+        m.writeUpdateCache({ lastCheck: 1_000_000, latest: '99.0.0' });
+        const log = jest.spyOn(console, 'log').mockImplementation(() => { });
+        const spawnWorker = jest.fn();
+        m.maybeNotifyUpdate({ now: 1_000_000 + 1000, spawnWorker });
+        expect(log.mock.calls.flat().join('\n')).toContain('99.0.0');
+        expect(spawnWorker).not.toHaveBeenCalled();
+        log.mockRestore();
+    });
+    it('cache viejo (>24h) dispara refresh en background', () => {
+        const m = require('../../src/core/update-check');
+        m.writeUpdateCache({ lastCheck: 0, latest: null });
+        const spawnWorker = jest.fn();
+        m.maybeNotifyUpdate({ now: 25 * 60 * 60 * 1000, spawnWorker });
+        expect(spawnWorker).toHaveBeenCalledTimes(1);
+    });
+    it('AWM_NO_UPDATE_CHECK desactiva todo', () => {
+        process.env.AWM_NO_UPDATE_CHECK = '1';
+        const m = require('../../src/core/update-check');
+        m.writeUpdateCache({ lastCheck: 0, latest: '99.0.0' });
+        const log = jest.spyOn(console, 'log').mockImplementation(() => { });
+        const spawnWorker = jest.fn();
+        m.maybeNotifyUpdate({ now: Date.now(), spawnWorker });
+        expect(log).not.toHaveBeenCalled();
+        expect(spawnWorker).not.toHaveBeenCalled();
+        log.mockRestore();
+        delete process.env.AWM_NO_UPDATE_CHECK;
+    });
+    it('offerSelfUpdate corre el runner al confirmar y degrada a aviso si falla', async () => {
+        const m = require('../../src/core/update-check');
+        const runner = jest.fn().mockReturnValue({ status: 1 });
+        const warn = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        await m.offerSelfUpdate({ current: '2.0.0', latest: '2.1.0', confirmImpl: async () => true, runner });
+        expect(runner).toHaveBeenCalled();
+        expect(warn.mock.calls.flat().join('\n')).toContain('npm i -g agentic-workflow-manager');
+        warn.mockRestore();
+    });
+    it('offerSelfUpdate escribe cache cuando ya está actualizado (TTL reset)', async () => {
+        const m = require('../../src/core/update-check');
+        const fakeFetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ version: '2.0.0' }) });
+        await m.offerSelfUpdate({ current: '2.0.0', fetchImpl: fakeFetch });
+        const cache = m.readUpdateCache();
+        expect(cache).not.toBeNull();
+        expect(cache.latest).toBe('2.0.0');
+        expect(cache.lastCheck).toBeGreaterThan(0);
+    });
+});

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

@@ -0,0 +1,169 @@
+"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/versioning.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' });
+/** Repo fuente con un commit inicial y un commit+tag por cada versión dada (en orden). */
+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 cloneOf(source, base, name) {
+    const dir = path_1.default.join(base, name);
+    GIT(base, `clone -q ${source} ${name}`);
+    return dir;
+}
+describe('versioning core', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ver-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ver-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;
+    });
+    describe('resolveTargetRef', () => {
+        it('stable sin pin → último tag con orden semver numérico (v1.10.0 > v1.9.0)', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.9.0', '1.10.0']);
+            const clone = cloneOf(source, tmpWork, 'clone');
+            const { resolveTargetRef } = require('../../src/core/versioning');
+            const r = await resolveTargetRef(clone, { channel: 'stable' });
+            expect(r).toEqual({ kind: 'tag', ref: 'v1.10.0', version: '1.10.0' });
+        });
+        it('pin exacto gana, con y sin prefijo v', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0', '1.1.0']);
+            const clone = cloneOf(source, tmpWork, 'clone');
+            const { resolveTargetRef } = require('../../src/core/versioning');
+            expect(await resolveTargetRef(clone, { pin: '1.0.0', channel: 'stable' }))
+                .toEqual({ kind: 'tag', ref: 'v1.0.0', version: '1.0.0' });
+            expect(await resolveTargetRef(clone, { pin: 'v1.0.0', channel: 'stable' }))
+                .toEqual({ kind: 'tag', ref: 'v1.0.0', version: '1.0.0' });
+        });
+        it('pin inexistente → error que lista las versiones disponibles', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+            const clone = cloneOf(source, tmpWork, 'clone');
+            const { resolveTargetRef } = require('../../src/core/versioning');
+            await expect(resolveTargetRef(clone, { pin: '9.9.9', channel: 'stable' }))
+                .rejects.toThrow(/v9\.9\.9.*v1\.0\.0/s);
+        });
+        it('sin tags + stable → head-fallback al default branch', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', []);
+            const clone = cloneOf(source, tmpWork, 'clone');
+            const { resolveTargetRef } = require('../../src/core/versioning');
+            const r = await resolveTargetRef(clone, { channel: 'stable' });
+            expect(r).toEqual({ kind: 'head-fallback', ref: 'main' });
+        });
+        it('canal dev → head del default branch aunque haya tags', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+            const clone = cloneOf(source, tmpWork, 'clone');
+            const { resolveTargetRef } = require('../../src/core/versioning');
+            const r = await resolveTargetRef(clone, { channel: 'dev' });
+            expect(r).toEqual({ kind: 'head', ref: 'main' });
+        });
+        it('tags no semver se ignoran', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+            GIT(source, 'tag latest');
+            GIT(source, 'tag v2.0');
+            GIT(source, 'tag release-3.0.0');
+            const clone = cloneOf(source, tmpWork, 'clone');
+            const { resolveTargetRef } = require('../../src/core/versioning');
+            const r = await resolveTargetRef(clone, { channel: 'stable' });
+            expect(r).toEqual({ kind: 'tag', ref: 'v1.0.0', version: '1.0.0' });
+        });
+        it('hace fetch: ve tags creados en el remote después del clone', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+            const clone = cloneOf(source, tmpWork, 'clone');
+            // tag nuevo en el remote, post-clone
+            fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), '1.1.0');
+            GIT(source, 'add -A');
+            GIT(source, 'commit -qm 1.1.0');
+            GIT(source, 'tag v1.1.0');
+            const { resolveTargetRef } = require('../../src/core/versioning');
+            const r = await resolveTargetRef(clone, { channel: 'stable' });
+            expect(r).toEqual({ kind: 'tag', ref: 'v1.1.0', version: '1.1.0' });
+        });
+    });
+    describe('currentVersion', () => {
+        it('en checkout exacto de un tag semver → versión sin prefijo v', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.2.0']);
+            const clone = cloneOf(source, tmpWork, 'clone');
+            GIT(clone, 'checkout -q v1.2.0');
+            const { currentVersion } = require('../../src/core/versioning');
+            expect(await currentVersion(clone)).toBe('1.2.0');
+        });
+        it('siguiendo un branch (sin tag exacto en HEAD) → null', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+            // commit posterior al tag para que HEAD no coincida con ningún tag
+            fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), 'post');
+            GIT(source, 'add -A');
+            GIT(source, 'commit -qm post');
+            const clone = cloneOf(source, tmpWork, 'clone');
+            const { currentVersion } = require('../../src/core/versioning');
+            expect(await currentVersion(clone)).toBeNull();
+        });
+        it('tag exacto pero no semver → null', async () => {
+            const source = makeTaggedRepo(tmpWork, 'src', []);
+            GIT(source, 'tag release-1');
+            const clone = cloneOf(source, tmpWork, 'clone');
+            GIT(clone, 'checkout -q release-1');
+            const { currentVersion } = require('../../src/core/versioning');
+            expect(await currentVersion(clone)).toBeNull();
+        });
+    });
+    describe('machineVersionOpts', () => {
+        it('sin preferences → channel stable, sin pin', () => {
+            const { machineVersionOpts } = require('../../src/core/versioning');
+            expect(machineVersionOpts('base')).toEqual({ pin: undefined, channel: 'stable' });
+        });
+        it('lee channel dev y pin por nombre desde preferences', () => {
+            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', pins: { base: '1.2.0', equipo: '0.3.0' } }));
+            const { machineVersionOpts } = require('../../src/core/versioning');
+            expect(machineVersionOpts('base')).toEqual({ pin: '1.2.0', channel: 'dev' });
+            expect(machineVersionOpts('equipo')).toEqual({ pin: '0.3.0', channel: 'dev' });
+            expect(machineVersionOpts('otro')).toEqual({ pin: undefined, channel: 'dev' });
+        });
+        it('preferences corruptas → defaults (stable, sin pin)', () => {
+            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'), '{not json');
+            const { machineVersionOpts } = require('../../src/core/versioning');
+            expect(machineVersionOpts('base')).toEqual({ pin: undefined, channel: 'stable' });
+        });
+    });
+});