agentic-workflow-manager 2.0.0

package/dist/tests/commands/hooks/resync.test.js

@@ -0,0 +1,135 @@
+"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('resyncInstalledHooks', () => {
+    let tmpHome;
+    let tmpRegistry;
+    let originalHome;
+    let originalAwmHome;
+    function writeRegistry(sessionStartContent) {
+        const regHooks = path_1.default.join(tmpRegistry, 'hooks');
+        const regSkill = path_1.default.join(tmpRegistry, 'skills/using-awm');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.mkdirSync(regSkill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), sessionStartContent, { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+    }
+    function writeSettingsWithAwmEntry(scriptsDir) {
+        const settingsPath = path_1.default.join(tmpHome, '.claude/settings.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(settingsPath), { recursive: true });
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        matcher: 'startup|clear|compact',
+                        hooks: [{ type: 'command', command: `${path_1.default.join(scriptsDir, 'run-hook.cmd')} session-start`, async: false }]
+                    }]
+            }
+        }, null, 2));
+    }
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-resync-'));
+        tmpRegistry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-resync-registry-'));
+        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(tmpRegistry, { 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('refreshes stale COPIED hook scripts when the settings entry is present', () => {
+        writeRegistry('#!/usr/bin/env bash\necho "NEW VERSION"');
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'session-start'), '#!/usr/bin/env bash\necho "OLD VERSION"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        writeSettingsWithAwmEntry(scriptsDir);
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(tmpRegistry);
+        expect(results).toEqual([{ agent: 'claude-code', action: 'resynced' }]);
+        const synced = fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8');
+        expect(synced).toContain('NEW VERSION');
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(false);
+        expect(() => fs_1.default.accessSync(path_1.default.join(scriptsDir, 'session-start'), fs_1.default.constants.X_OK)).not.toThrow();
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(true);
+    });
+    it('does NOT touch anything when the hook was never installed (no settings entry)', () => {
+        writeRegistry('#!/usr/bin/env bash\necho "NEW VERSION"');
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(tmpRegistry);
+        expect(results).toEqual([{ agent: 'claude-code', action: 'not-installed' }]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/hooks/session-start'))).toBe(false);
+    });
+    it('preserves symlink install method', () => {
+        writeRegistry('#!/usr/bin/env bash\necho "V2"');
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+        fs_1.default.symlinkSync(path_1.default.join(tmpRegistry, 'hooks/session-start'), path_1.default.join(scriptsDir, 'session-start'));
+        fs_1.default.symlinkSync(path_1.default.join(tmpRegistry, 'hooks/run-hook.cmd'), path_1.default.join(scriptsDir, 'run-hook.cmd'));
+        writeSettingsWithAwmEntry(scriptsDir);
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(tmpRegistry);
+        expect(results).toEqual([{ agent: 'claude-code', action: 'resynced' }]);
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(true);
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(true);
+    });
+    it('skips with registry-missing when the registry has no hooks dir', () => {
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'session-start'), '#!/usr/bin/env bash\necho "OLD"', { mode: 0o755 });
+        writeSettingsWithAwmEntry(scriptsDir);
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(tmpRegistry);
+        expect(results).toEqual([{ agent: 'claude-code', action: 'registry-missing' }]);
+        expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
+    });
+    it('re-creates session-start as copy when scriptsDir exists but session-start is missing', () => {
+        writeRegistry('#!/usr/bin/env bash\necho "FRESH"');
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+        // session-start intentionally absent — only run-hook.cmd exists
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        writeSettingsWithAwmEntry(scriptsDir);
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(tmpRegistry);
+        expect(results).toEqual([{ agent: 'claude-code', action: 'resynced' }]);
+        expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'session-start'))).toBe(true);
+        // detectInstallMethod fell back to copy since lstatSync threw
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(false);
+    });
+    it('returns registry-missing when run-hook.cmd is absent from registry', () => {
+        // Partial registry: only session-start present, run-hook.cmd absent
+        const regHooks = path_1.default.join(tmpRegistry, 'hooks');
+        const regSkill = path_1.default.join(tmpRegistry, 'skills/using-awm');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.mkdirSync(regSkill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "V2"', { mode: 0o755 });
+        // run-hook.cmd intentionally NOT written
+        fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---');
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'session-start'), '#!/usr/bin/env bash\necho "OLD"', { mode: 0o755 });
+        writeSettingsWithAwmEntry(scriptsDir);
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(tmpRegistry);
+        expect(results).toEqual([{ agent: 'claude-code', action: 'registry-missing' }]);
+        // old script left intact — never leave user without hook
+        expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
+    });
+});

package/dist/tests/commands/hooks/router.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+// @clack/prompts ships as ESM; mock it so Jest (CommonJS mode) can load the router
+jest.mock('@clack/prompts', () => ({
+    confirm: jest.fn(),
+    isCancel: jest.fn(),
+}));
+// Mock heavy dependencies that are not needed to verify command registration
+jest.mock('../../../src/utils/config', () => ({
+    getPreferences: jest.fn(() => ({ installMethod: 'symlink', defaultAgent: 'claude-code', defaultScope: 'global' })),
+}));
+jest.mock('../../../src/commands/hooks/install', () => ({ installHook: jest.fn() }));
+jest.mock('../../../src/commands/hooks/uninstall', () => ({ uninstallHook: jest.fn() }));
+jest.mock('../../../src/commands/hooks/status', () => ({ computeHookStatus: jest.fn() }));
+describe('hooks command router', () => {
+    it('registers install, uninstall, and status subcommands', () => {
+        const program = new commander_1.Command();
+        const { registerHooksCommand } = require('../../../src/commands/hooks');
+        registerHooksCommand(program);
+        const hooks = program.commands.find((c) => c.name() === 'hooks');
+        expect(hooks).toBeDefined();
+        const subNames = hooks.commands.map((c) => c.name());
+        expect(subNames).toEqual(expect.arrayContaining(['install', 'uninstall', 'status']));
+    });
+});

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

@@ -0,0 +1,88 @@
+"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('computeHookStatus', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-'));
+        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 setupInstalledHook(scriptContent = '#!/usr/bin/env bash\necho "{}"') {
+        const hooksDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.mkdirSync(hooksDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(hooksDir, 'session-start'), scriptContent, { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(hooksDir, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(hooksDir, 'using-awm.md'), '# using-awm\nMUST invoke skills.\n');
+        const claudeDir = path_1.default.join(tmpHome, '.claude');
+        fs_1.default.mkdirSync(claudeDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeDir, 'settings.json'), JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        matcher: 'startup|clear|compact',
+                        hooks: [{ type: 'command', command: `${hooksDir}/run-hook.cmd session-start`, async: false }]
+                    }]
+            }
+        }, null, 2));
+    }
+    it('reports HEALTHY when everything is in place', () => {
+        setupInstalledHook();
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const result = computeHookStatus('claude-code');
+        expect(result.overall).toBe('HEALTHY');
+        expect(result.checks.bootstrapSkill.ok).toBe(true);
+        expect(result.checks.sessionStartScript.ok).toBe(true);
+        expect(result.checks.runHookWrapper.ok).toBe(true);
+        expect(result.checks.settingsEntry.ok).toBe(true);
+    });
+    it('reports DEGRADED when bootstrap skill is missing', () => {
+        setupInstalledHook();
+        fs_1.default.unlinkSync(path_1.default.join(tmpHome, '.awm/hooks/using-awm.md'));
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const result = computeHookStatus('claude-code');
+        expect(result.overall).toBe('DEGRADED');
+        expect(result.checks.bootstrapSkill.ok).toBe(false);
+    });
+    it('reports NOT_INSTALLED when settings.json has no AWM entry', () => {
+        setupInstalledHook();
+        const claudeDir = path_1.default.join(tmpHome, '.claude');
+        fs_1.default.writeFileSync(path_1.default.join(claudeDir, 'settings.json'), JSON.stringify({}, null, 2));
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const result = computeHookStatus('claude-code');
+        expect(result.overall).toBe('NOT_INSTALLED');
+        expect(result.checks.settingsEntry.ok).toBe(false);
+    });
+    it('reports DEGRADED when script is missing executable bit', () => {
+        setupInstalledHook();
+        fs_1.default.chmodSync(path_1.default.join(tmpHome, '.awm/hooks/session-start'), 0o644);
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const result = computeHookStatus('claude-code');
+        expect(result.overall).toBe('DEGRADED');
+        expect(result.checks.sessionStartScript.ok).toBe(false);
+    });
+    it('throws when agent target has no hooks config', () => {
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        expect(() => computeHookStatus('antigravity')).toThrow(/hooks not supported/i);
+    });
+});

package/dist/tests/commands/hooks/uninstall.test.js

@@ -0,0 +1,104 @@
+"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('uninstallHook', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-uninstall-'));
+        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 writeSettings(content) {
+        const claudeDir = path_1.default.join(tmpHome, '.claude');
+        fs_1.default.mkdirSync(claudeDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeDir, 'settings.json'), JSON.stringify(content, null, 2));
+    }
+    function readSettings() {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf-8'));
+    }
+    it('removes only the AWM entry, preserves other SessionStart entries', () => {
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        writeSettings({
+            theme: 'dark',
+            hooks: {
+                SessionStart: [
+                    { matcher: 'startup', hooks: [{ type: 'command', command: '/other/plugin' }] },
+                    { matcher: 'startup|clear|compact', hooks: [{ type: 'command', command: `${scriptsDir}/run-hook.cmd session-start`, async: false }] }
+                ]
+            }
+        });
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        const result = uninstallHook({ agent: 'claude-code' });
+        expect(result.status).toBe('uninstalled');
+        const settings = readSettings();
+        expect(settings.theme).toBe('dark');
+        expect(settings.hooks.SessionStart).toHaveLength(1);
+        expect(settings.hooks.SessionStart[0].hooks[0].command).toBe('/other/plugin');
+    });
+    it('removes the SessionStart key entirely if AWM was the only entry', () => {
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        writeSettings({
+            hooks: {
+                SessionStart: [
+                    { matcher: 'startup|clear|compact', hooks: [{ type: 'command', command: `${scriptsDir}/run-hook.cmd session-start`, async: false }] }
+                ]
+            }
+        });
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        uninstallHook({ agent: 'claude-code' });
+        const settings = readSettings();
+        expect(settings.hooks?.SessionStart).toBeUndefined();
+    });
+    it('is a no-op when no AWM entry exists', () => {
+        writeSettings({
+            hooks: {
+                SessionStart: [{ matcher: 'startup', hooks: [{ type: 'command', command: '/other/plugin' }] }]
+            }
+        });
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        const result = uninstallHook({ agent: 'claude-code' });
+        expect(result.status).toBe('not-installed');
+        const settings = readSettings();
+        expect(settings.hooks.SessionStart).toHaveLength(1);
+    });
+    it('is a no-op when settings.json does not exist', () => {
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        const result = uninstallHook({ agent: 'claude-code' });
+        expect(result.status).toBe('not-installed');
+    });
+    it('creates a backup before modifying', () => {
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        writeSettings({
+            hooks: {
+                SessionStart: [
+                    { matcher: 'startup|clear|compact', hooks: [{ type: 'command', command: `${scriptsDir}/run-hook.cmd session-start`, async: false }] }
+                ]
+            }
+        });
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        const result = uninstallHook({ agent: 'claude-code' });
+        expect(result.backupPath).not.toBeNull();
+        expect(fs_1.default.existsSync(result.backupPath)).toBe(true);
+    });
+});

package/dist/tests/commands/init.test.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_1 = require("../../src/commands/init");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('makeConfirmExtensions (#1 empty-multiselect guard)', () => {
+    it('returns [] for empty proposed without invoking clack (non-yes path)', async () => {
+        const fn = (0, init_1.makeConfirmExtensions)(false);
+        await expect(fn([], [])).resolves.toEqual([]);
+    });
+    it('auto-confirms all proposed in --yes mode', async () => {
+        const fn = (0, init_1.makeConfirmExtensions)(true);
+        await expect(fn(['frontend'], ['package.json: next'])).resolves.toEqual(['frontend']);
+    });
+});
+function report(over = {}) {
+    return {
+        results: [{ id: 'machine.cli', level: 'machine', label: 'CLI v1.0.0', status: 'ok', remedy: { kind: 'none' } }],
+        overall: 'degraded', hasProject: false, ...over,
+    };
+}
+describe('renderInitOutcome', () => {
+    it('renders before, actions and after blocks, reusing the doctor dashboard', () => {
+        const outcome = {
+            steps: [
+                { id: 'machine.cache', level: 'machine', action: 'applied', detail: 'cache clonado' },
+                { id: 'project.constitution', level: 'project', action: 'pending', detail: 'skill: project-constitution' },
+            ],
+            applied: 1, pending: 1, failed: 0,
+            before: report(), after: report({ overall: 'degraded' }),
+        };
+        const out = (0, init_1.renderInitOutcome)(outcome);
+        expect(out).toContain('AWM · init');
+        expect(out).toContain('Estado inicial');
+        expect(out).toContain('Acciones');
+        expect(out).toContain('machine.cache');
+        expect(out).toContain('skill: project-constitution');
+        expect(out).toContain('Estado final');
+        expect(out).toContain('AWM · estado del harness'); // viene de renderReport
+        expect(out).toContain('1 pasos requieren un agente');
+    });
+});
+describe('runInit', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    let writeSpy;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-run-'));
+        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();
+        writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        writeSpy.mockRestore();
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('returns exit 1 on a bare HOME and never prompts with --yes (cache stubbed)', async () => {
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { } } });
+        expect(code).toBe(1); // cache/hook/devCore siguen ausentes (syncCache no-op) → degradado
+    });
+    it('--json emits a parseable InitOutcome', async () => {
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({ cwd: tmpHome, yes: true, json: true, actions: { syncCache: async () => { } } });
+        const written = writeSpy.mock.calls.map((c) => c[0]).join('');
+        const parsed = JSON.parse(written);
+        expect(Array.isArray(parsed.steps)).toBe(true);
+        expect(parsed.after.overall).toBe('degraded');
+        expect(code).toBe(1);
+    });
+});

package/dist/tests/commands/ledger/index.test.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const ledger_1 = require("../../../src/commands/ledger");
+const store_1 = require("../../../src/core/ledger/store");
+function mkTmp() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ledger-cli-'));
+}
+function run(argv, cwd) {
+    const prog = new commander_1.Command();
+    prog.exitOverride();
+    (0, ledger_1.registerLedgerCommand)(prog);
+    const spy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    const cwdSpy = jest.spyOn(process, 'cwd').mockReturnValue(cwd);
+    try {
+        prog.parse(['node', 'awm', 'ledger', ...argv]);
+    }
+    finally {
+        cwdSpy.mockRestore();
+    }
+    const out = spy.mock.calls.map(c => String(c[0])).join('');
+    spy.mockRestore();
+    return out;
+}
+describe('awm ledger CLI', () => {
+    let cwd;
+    beforeEach(() => { cwd = mkTmp(); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    test('add writes an entry to the current branch ledger', () => {
+        run(['add', '--branch', 'feat-x', '--polarity', 'finding', '--class', 'logica',
+            '--signature', 'sig-1', '--severity', 'blocker', '--desc', 'boom', '--ref', 'a.ts:1'], cwd);
+        const entries = (0, store_1.listEntries)(cwd, 'feat-x');
+        expect(entries).toHaveLength(1);
+        expect(entries[0]).toMatchObject({ signature: 'sig-1', polarity: 'finding', class: 'logica' });
+        expect(entries[0].ts).toMatch(/\d{4}-\d{2}-\d{2}T/);
+    });
+    test('list emits the branch entries as JSON', () => {
+        run(['add', '--branch', 'feat-x', '--polarity', 'win', '--class', 'proceso',
+            '--signature', 'good', '--severity', 'info', '--desc', 'nice'], cwd);
+        const out = run(['list', '--branch', 'feat-x'], cwd);
+        expect(JSON.parse(out)).toHaveLength(1);
+        expect(JSON.parse(out)[0].polarity).toBe('win');
+    });
+    test('recurring reports clusters at or above --min', () => {
+        for (const _ of [0, 1]) {
+            run(['add', '--branch', 'feat-x', '--polarity', 'finding', '--class', 'logica',
+                '--signature', 'dup', '--severity', 'minor', '--desc', 'x'], cwd);
+        }
+        const out = run(['recurring', '--branch', 'feat-x', '--min', '2'], cwd);
+        expect(JSON.parse(out)).toMatchObject([{ signature: 'dup', count: 2 }]);
+    });
+    test('archive removes the active ledger', () => {
+        run(['add', '--branch', 'feat-x', '--polarity', 'finding', '--class', 'logica',
+            '--signature', 's', '--severity', 'minor', '--desc', 'x'], cwd);
+        run(['archive', '--branch', 'feat-x'], cwd);
+        expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([]);
+    });
+});

package/dist/tests/commands/pin.test.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/commands/pin.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('pin/unpin (editores de preferences)', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pin-home-'));
+        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;
+    });
+    const readPrefs = () => JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/preferences.json'), 'utf-8'));
+    it('setPin escribe pins.base normalizado (acepta prefijo v)', () => {
+        const { setPin } = require('../../src/commands/pin');
+        setPin('base', 'v1.2.0');
+        expect(readPrefs().pins).toEqual({ base: '1.2.0' });
+    });
+    it('setPin acepta un registry adicional configurado', () => {
+        const { writeRegistriesConfig } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'equipo', remote: '/tmp/x' }]);
+        const { setPin } = require('../../src/commands/pin');
+        setPin('equipo', '0.3.0');
+        expect(readPrefs().pins).toEqual({ equipo: '0.3.0' });
+    });
+    it('setPin rechaza un registry desconocido listando los válidos', () => {
+        const { setPin } = require('../../src/commands/pin');
+        expect(() => setPin('nope', '1.0.0')).toThrow(/nope.*base/s);
+    });
+    it('setPin rechaza versión malformada', () => {
+        const { setPin } = require('../../src/commands/pin');
+        expect(() => setPin('base', '1.2')).toThrow(/X\.Y\.Z/);
+        expect(() => setPin('base', 'latest')).toThrow(/X\.Y\.Z/);
+    });
+    it('removePin borra la entrada y reporta si existía', () => {
+        const { setPin, removePin } = require('../../src/commands/pin');
+        setPin('base', '1.2.0');
+        expect(removePin('base')).toBe(true);
+        expect(readPrefs().pins).toEqual({});
+        expect(removePin('base')).toBe(false);
+    });
+    it('setPin preserva las demás preferencias y pins existentes', () => {
+        const { setPin } = require('../../src/commands/pin');
+        setPin('base', '1.0.0');
+        const { writeRegistriesConfig } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'equipo', remote: '/tmp/x' }]);
+        setPin('equipo', '2.0.0');
+        const prefs = readPrefs();
+        expect(prefs.pins).toEqual({ base: '1.0.0', equipo: '2.0.0' });
+        expect(prefs.defaultAgent).toBeDefined();
+    });
+});