agentic-workflow-manager 2.0.0

package/dist/tests/core/ledger/store.test.js

@@ -0,0 +1,122 @@
+"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 store_1 = require("../../../src/core/ledger/store");
+function mkTmp() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ledger-'));
+}
+function entry(over = {}) {
+    return {
+        ts: '2026-06-06T00:00:00.000Z',
+        branch: 'feat-x',
+        phase: 'post-qa',
+        source_skill: 'post-implementation-qa',
+        polarity: 'finding',
+        class: 'logica',
+        signature: 'public-fn-returns-infinity',
+        severity: 'blocker',
+        desc: 'splitBill(100,0) returns Infinity',
+        ref: 'src/split.ts:12',
+        ...over,
+    };
+}
+describe('ledger store — add/list', () => {
+    let cwd;
+    beforeEach(() => { cwd = mkTmp(); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    test('ledgerPath sanitizes branch slashes into the filename', () => {
+        expect((0, store_1.ledgerPath)(cwd, 'feature/foo')).toBe(path_1.default.join(cwd, '.awm', 'ledger', 'feature__foo.jsonl'));
+    });
+    test('addEntry creates .awm/ledger/ and appends one jsonl line', () => {
+        (0, store_1.addEntry)(cwd, entry());
+        const raw = fs_1.default.readFileSync((0, store_1.ledgerPath)(cwd, 'feat-x'), 'utf-8');
+        expect(raw.trim().split('\n')).toHaveLength(1);
+        expect(JSON.parse(raw.trim())).toMatchObject({ signature: 'public-fn-returns-infinity', polarity: 'finding' });
+    });
+    test('addEntry appends without clobbering prior entries', () => {
+        (0, store_1.addEntry)(cwd, entry());
+        (0, store_1.addEntry)(cwd, entry({ signature: 'second', desc: 'another' }));
+        expect((0, store_1.listEntries)(cwd, 'feat-x')).toHaveLength(2);
+    });
+    test('listEntries on a branch with no ledger returns []', () => {
+        expect((0, store_1.listEntries)(cwd, 'never-touched')).toEqual([]);
+    });
+    test('listEntries skips a malformed line without throwing', () => {
+        const p = (0, store_1.ledgerPath)(cwd, 'feat-x');
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.writeFileSync(p, JSON.stringify(entry()) + '\n' + 'NOT JSON\n' + JSON.stringify(entry({ signature: 's2' })) + '\n');
+        const got = (0, store_1.listEntries)(cwd, 'feat-x');
+        expect(got).toHaveLength(2);
+        expect(got.map(e => e.signature)).toEqual(['public-fn-returns-infinity', 's2']);
+    });
+});
+describe('ledger store — detectBranch', () => {
+    test('falls back to _no-branch outside a git repo', () => {
+        const tmp = mkTmp();
+        try {
+            expect((0, store_1.detectBranch)(tmp)).toBe('_no-branch');
+        }
+        finally {
+            fs_1.default.rmSync(tmp, { recursive: true, force: true });
+        }
+    });
+    test('returns the current branch name from an actual git repo', () => {
+        const { execSync: exec } = require('child_process');
+        const tmp = mkTmp();
+        try {
+            exec('git init && git -c user.email=test@test.com -c user.name=Test commit --allow-empty -m init && git checkout -b test-ledger-branch', { cwd: tmp, stdio: 'ignore' });
+            expect((0, store_1.detectBranch)(tmp)).toBe('test-ledger-branch');
+        }
+        finally {
+            fs_1.default.rmSync(tmp, { recursive: true, force: true });
+        }
+    });
+});
+describe('ledger store — recurring', () => {
+    let cwd;
+    beforeEach(() => { cwd = mkTmp(); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    test('groups by signature and reports clusters with count >= min', () => {
+        (0, store_1.addEntry)(cwd, entry({ signature: 'dup' }));
+        (0, store_1.addEntry)(cwd, entry({ signature: 'dup' }));
+        (0, store_1.addEntry)(cwd, entry({ signature: 'solo' }));
+        const clusters = (0, store_1.recurring)(cwd, 'feat-x', 2);
+        expect(clusters).toHaveLength(1);
+        expect(clusters[0]).toMatchObject({ signature: 'dup', count: 2 });
+        expect(clusters[0].entries).toHaveLength(2);
+    });
+    test('respects --min: count 2 is excluded when min is 3', () => {
+        (0, store_1.addEntry)(cwd, entry({ signature: 'dup' }));
+        (0, store_1.addEntry)(cwd, entry({ signature: 'dup' }));
+        expect((0, store_1.recurring)(cwd, 'feat-x', 3)).toEqual([]);
+    });
+    test('sorts clusters by count descending', () => {
+        (0, store_1.addEntry)(cwd, entry({ signature: 'a' }));
+        (0, store_1.addEntry)(cwd, entry({ signature: 'a' }));
+        (0, store_1.addEntry)(cwd, entry({ signature: 'b' }));
+        (0, store_1.addEntry)(cwd, entry({ signature: 'b' }));
+        (0, store_1.addEntry)(cwd, entry({ signature: 'b' }));
+        const clusters = (0, store_1.recurring)(cwd, 'feat-x', 2);
+        expect(clusters.map(c => c.signature)).toEqual(['b', 'a']);
+    });
+});
+describe('ledger store — archive', () => {
+    let cwd;
+    beforeEach(() => { cwd = mkTmp(); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    test('moves the branch ledger into archive/ and leaves no active ledger', () => {
+        (0, store_1.addEntry)(cwd, entry());
+        const moved = (0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000');
+        expect(moved).toBe(true);
+        expect(fs_1.default.existsSync((0, store_1.ledgerPath)(cwd, 'feat-x'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, '.awm', 'ledger', 'archive', 'feat-x-20260606T000000.jsonl'))).toBe(true);
+    });
+    test('archiving a non-existent ledger is a no-op returning false', () => {
+        expect((0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000')).toBe(false);
+    });
+});

package/dist/tests/core/miro-layout.test.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const miro_1 = require("../../src/core/miro");
+const SIMPLE_MAP = {
+    project: 'Test Project',
+    goal: 'Test goal',
+    activities: [
+        {
+            title: 'Actividad 1',
+            tasks: [
+                {
+                    title: 'Task 1.1',
+                    stories: [
+                        { release: 'MVP', title: 'Story A' },
+                        { release: 'Release 2', title: 'Story B' },
+                    ],
+                },
+            ],
+        },
+        {
+            title: 'Actividad 2',
+            tasks: [
+                {
+                    title: 'Task 2.1',
+                    stories: [
+                        { release: 'MVP', title: 'Story C' },
+                    ],
+                },
+                {
+                    title: 'Task 2.2',
+                    stories: [],
+                },
+            ],
+        },
+    ],
+};
+// New layout: column = Task. Total task columns = 3 (1 + 2)
+// CARD_W=260, COL_W=280, PADDING=40
+// frameWidth = 40*2 + 3*280 - 20 = 900
+// Activity 1 spans 1 col (width=260), Activity 2 spans 2 cols (width=540)
+describe('computeLayout', () => {
+    it('returns one card per activity', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const activities = items.filter(i => i.kind === 'activity');
+        expect(activities).toHaveLength(2);
+    });
+    it('returns one card per task', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const tasks = items.filter(i => i.kind === 'task');
+        expect(tasks).toHaveLength(3);
+    });
+    it('returns one card per story', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const stories = items.filter(i => i.kind === 'story');
+        expect(stories).toHaveLength(3);
+    });
+    it('returns one swimlane label per unique release', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const swimlanes = items.filter(i => i.kind === 'swimlane');
+        expect(swimlanes).toHaveLength(2);
+        expect(swimlanes.map(s => s.title)).toContain('MVP');
+        expect(swimlanes.map(s => s.title)).toContain('Release 2');
+    });
+    it('activity with 1 task has same x as its task (centered over single column)', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const act1 = items.find(i => i.kind === 'activity' && i.title === 'Actividad 1');
+        const task11 = items.find(i => i.kind === 'task' && i.title === 'Task 1.1');
+        expect(act1.x).toBe(task11.x);
+    });
+    it('activity with 2 tasks is centered between its task columns', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const act2 = items.find(i => i.kind === 'activity' && i.title === 'Actividad 2');
+        const task21 = items.find(i => i.kind === 'task' && i.title === 'Task 2.1');
+        const task22 = items.find(i => i.kind === 'task' && i.title === 'Task 2.2');
+        // Activity center should be midpoint of its task columns
+        expect(act2.x).toBe((task21.x + task22.x) / 2);
+    });
+    it('activity with 2 tasks is wider than activity with 1 task', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const act1 = items.find(i => i.kind === 'activity' && i.title === 'Actividad 1');
+        const act2 = items.find(i => i.kind === 'activity' && i.title === 'Actividad 2');
+        expect(act2.width).toBeGreaterThan(act1.width);
+    });
+    it('activities in different positions have different x values', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const act1 = items.find(i => i.kind === 'activity' && i.title === 'Actividad 1');
+        const act2 = items.find(i => i.kind === 'activity' && i.title === 'Actividad 2');
+        expect(act1.x).not.toBe(act2.x);
+    });
+    it('frame width scales with total number of task columns', () => {
+        const { frameWidth } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        // 3 task columns
+        const oneTask = { ...SIMPLE_MAP, activities: [SIMPLE_MAP.activities[0]] };
+        const { frameWidth: oneWidth } = (0, miro_1.computeLayout)(oneTask);
+        // 1 task column
+        expect(frameWidth).toBeGreaterThan(oneWidth);
+    });
+    it('frame height is positive', () => {
+        const { frameHeight } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        expect(frameHeight).toBeGreaterThan(0);
+    });
+    it('assigns correct colors by kind', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const act = items.find(i => i.kind === 'activity');
+        const task = items.find(i => i.kind === 'task');
+        const story = items.find(i => i.kind === 'story');
+        const swimlane = items.find(i => i.kind === 'swimlane');
+        expect(act.color).toBe('#ffdc4a');
+        expect(task.color).toBe('#659df2');
+        expect(story.color).toBe('#ffffff');
+        expect(swimlane.color).toBeUndefined();
+    });
+    it('MVP swimlane appears before Release 2', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const swimlanes = items.filter(i => i.kind === 'swimlane');
+        const mvpIdx = swimlanes.findIndex(s => s.title === 'MVP');
+        const r2Idx = swimlanes.findIndex(s => s.title === 'Release 2');
+        expect(mvpIdx).toBeLessThan(r2Idx);
+    });
+    it('stories are placed below their corresponding task column', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        // Story A belongs to Task 1.1 → same column x
+        const task11 = items.find(i => i.kind === 'task' && i.title === 'Task 1.1');
+        const storyA = items.find(i => i.kind === 'story' && i.title === 'Story A');
+        expect(storyA.x).toBe(task11.x);
+        // Story C belongs to Task 2.1 → same column x
+        const task21 = items.find(i => i.kind === 'task' && i.title === 'Task 2.1');
+        const storyC = items.find(i => i.kind === 'story' && i.title === 'Story C');
+        expect(storyC.x).toBe(task21.x);
+    });
+    it('MVP swimlane Y is less than Release 2 swimlane Y (canvas coordinates)', () => {
+        const { items } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const mvp = items.find(i => i.kind === 'swimlane' && i.title === 'MVP');
+        const r2 = items.find(i => i.kind === 'swimlane' && i.title === 'Release 2');
+        expect(mvp.y).toBeLessThan(r2.y);
+    });
+    it('first activity Y is correct (frameTop + PADDING + TITLE_H + CARD_H/2)', () => {
+        const { items, frameHeight } = (0, miro_1.computeLayout)(SIMPLE_MAP);
+        const act1 = items.find(i => i.kind === 'activity' && i.title === 'Actividad 1');
+        const expectedY = -frameHeight / 2 + 40 + 50 + 50; // PADDING(40) + TITLE_H(50) + CARD_H/2(50)
+        expect(act1.y).toBe(expectedY);
+    });
+    it('handles empty activities gracefully', () => {
+        const emptyMap = { project: 'Empty', goal: '', activities: [] };
+        const { frameWidth, frameHeight, items } = (0, miro_1.computeLayout)(emptyMap);
+        expect(frameWidth).toBeGreaterThanOrEqual(0);
+        expect(frameHeight).toBeGreaterThanOrEqual(0);
+        expect(items).toHaveLength(0);
+    });
+});

package/dist/tests/core/profile-pins.test.js

@@ -0,0 +1,131 @@
+"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/profile-pins.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('verifyProjectPins (gate de awm sync)', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pins-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pins-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('match: máquina en la versión pineada → sin failures', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+        const { writeRegistriesConfig, syncRegistries } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries(); // queda en v1.0.0
+        const { verifyProjectPins } = require('../../src/core/profile-pins');
+        expect(await verifyProjectPins({ baseline: '1.0.0' })).toEqual([]);
+    });
+    it('mismatch: la máquina avanzó más allá del pin → failure con actual y required', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+        const { writeRegistriesConfig, syncRegistries } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries();
+        addRelease(source, '1.1.0');
+        await syncRegistries(); // máquina avanza a v1.1.0
+        const { verifyProjectPins } = require('../../src/core/profile-pins');
+        expect(await verifyProjectPins({ baseline: '1.0.0' })).toEqual([
+            { name: 'baseline', required: '1.0.0', actual: '1.1.0', reason: 'mismatch' },
+        ]);
+    });
+    it('registry pineado no configurado en la máquina → missing-registry', async () => {
+        const { verifyProjectPins } = require('../../src/core/profile-pins');
+        expect(await verifyProjectPins({ equipo: '2.0.0' })).toEqual([
+            { name: 'equipo', required: '2.0.0', actual: null, reason: 'missing-registry' },
+        ]);
+    });
+    it('máquina siguiendo HEAD (sin tag) con pin declarado → mismatch con actual null', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', []);
+        const { writeRegistriesConfig, syncRegistries } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries(); // head-fallback
+        const { verifyProjectPins } = require('../../src/core/profile-pins');
+        expect(await verifyProjectPins({ baseline: '1.0.0' })).toEqual([
+            { name: 'baseline', required: '1.0.0', actual: null, reason: 'mismatch' },
+        ]);
+    });
+    it('pin gate corre aunque extensions esté vacío (B1 regression)', async () => {
+        // Un profile {extensions: [], registries: {baseline: '1.0.0'}} con la máquina en v1.1.0
+        // DEBE producir mismatch — el early-exit de extensions no puede bypassear el gate.
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0', '1.1.0']);
+        const { writeRegistriesConfig, syncRegistries } = require('../../src/core/registries');
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries(); // máquina en v1.1.0
+        const { verifyProjectPins } = require('../../src/core/profile-pins');
+        const failures = await verifyProjectPins({ baseline: '1.0.0' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0]).toMatchObject({ name: 'baseline', required: '1.0.0', reason: 'mismatch' });
+    });
+    it('CRITERIO ROADMAP end-to-end: pineado no recibe main hasta bump; rollback funciona', async () => {
+        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
+        const { writeRegistriesConfig, syncRegistries } = require('../../src/core/registries');
+        const { savePreferences, getPreferences } = require('../../src/utils/config');
+        const { verifyProjectPins } = require('../../src/core/profile-pins');
+        const versionFile = path_1.default.join(tmpHome, '.awm/registries/baseline/VERSION');
+        // proyecto pineado a 1.0.0, máquina en 1.0.0 → ok
+        writeRegistriesConfig([{ name: 'baseline', remote: source }]);
+        await syncRegistries();
+        expect(await verifyProjectPins({ baseline: '1.0.0' })).toEqual([]);
+        // el remote avanza (release 1.1.0) y la máquina updatea → el proyecto pineado FALLA (no recibe el cambio en silencio)
+        addRelease(source, '1.1.0');
+        await syncRegistries();
+        expect(fs_1.default.readFileSync(versionFile, 'utf-8')).toBe('1.1.0');
+        expect((await verifyProjectPins({ baseline: '1.0.0' }))[0]?.reason).toBe('mismatch');
+        // bump explícito del profile → pasa
+        expect(await verifyProjectPins({ baseline: '1.1.0' })).toEqual([]);
+        // rollback: pin de máquina a 1.0.0 → contenido vuelve y el proyecto pineado a 1.0.0 pasa
+        const prefs = getPreferences();
+        savePreferences({ ...prefs, pins: { baseline: '1.0.0' } });
+        await syncRegistries();
+        expect(fs_1.default.readFileSync(versionFile, 'utf-8')).toBe('1.0.0');
+        expect(await verifyProjectPins({ baseline: '1.0.0' })).toEqual([]);
+    });
+});

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

@@ -0,0 +1,59 @@
+"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/profile-registries.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('profile.registries (pin de proyecto)', () => {
+    let tmpProj;
+    beforeEach(() => {
+        tmpProj = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-prof-'));
+        fs_1.default.mkdirSync(path_1.default.join(tmpProj, '.awm'), { recursive: true });
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpProj, { recursive: true, force: true });
+    });
+    const writeRaw = (obj) => fs_1.default.writeFileSync(path_1.default.join(tmpProj, '.awm/profile.json'), JSON.stringify(obj));
+    it('lee registries válido y normaliza el prefijo v', () => {
+        writeRaw({ extensions: [], registries: { base: 'v1.2.0', equipo: '0.3.0' } });
+        const { readProfile } = require('../../src/core/profile');
+        expect(readProfile(tmpProj).registries).toEqual({ base: '1.2.0', equipo: '0.3.0' });
+    });
+    it('profile sin registries → campo ausente (sin verificación)', () => {
+        writeRaw({ extensions: ['x'] });
+        const { readProfile } = require('../../src/core/profile');
+        const p = readProfile(tmpProj);
+        expect(p.extensions).toEqual(['x']);
+        expect(p.registries).toBeUndefined();
+    });
+    it('registries no-objeto → error explícito con path', () => {
+        writeRaw({ extensions: [], registries: ['base'] });
+        const { readProfile } = require('../../src/core/profile');
+        expect(() => readProfile(tmpProj)).toThrow(/profile.*registries/s);
+    });
+    it('versión malformada → error explícito que nombra la clave', () => {
+        writeRaw({ extensions: [], registries: { base: 'latest' } });
+        const { readProfile } = require('../../src/core/profile');
+        expect(() => readProfile(tmpProj)).toThrow(/base.*latest/s);
+    });
+    it('writeProfile + readProfile round-trip preserva registries', () => {
+        const { readProfile, writeProfile } = require('../../src/core/profile');
+        writeProfile(tmpProj, { extensions: ['a'], registries: { base: '1.0.0' } });
+        expect(readProfile(tmpProj)).toEqual({ extensions: ['a'], registries: { base: '1.0.0' } });
+    });
+    it.each([[''], ['.'], ['..'], ['a/b'], ['a\\b']])('clave "%s" en registries → error (path traversal guard)', (key) => {
+        writeRaw({ extensions: [], registries: { [key]: '1.0.0' } });
+        const { readProfile } = require('../../src/core/profile');
+        expect(() => readProfile(tmpProj)).toThrow(/not a valid registry name/);
+    });
+    it('addExtension preserva registries existente', () => {
+        const { readProfile, writeProfile, addExtension } = require('../../src/core/profile');
+        writeProfile(tmpProj, { extensions: [], registries: { base: '1.0.0' } });
+        addExtension(tmpProj, 'nuevo');
+        expect(readProfile(tmpProj)).toEqual({ extensions: ['nuevo'], registries: { base: '1.0.0' } });
+    });
+});

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

@@ -0,0 +1,110 @@
+"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 profile_1 = require("../../src/core/profile");
+function tmpRoot() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-profile-'));
+}
+describe('findProjectRoot', () => {
+    it('finds the root via a .git marker walking up from a subdir', () => {
+        const root = tmpRoot();
+        fs_1.default.mkdirSync(path_1.default.join(root, '.git'));
+        const sub = path_1.default.join(root, 'a', 'b');
+        fs_1.default.mkdirSync(sub, { recursive: true });
+        // realpathSync normalizes /private symlink prefixes on macOS tmp dirs.
+        expect((0, profile_1.findProjectRoot)(sub)).toBe(fs_1.default.realpathSync(root));
+    });
+    it('finds the root via package.json', () => {
+        const root = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        expect((0, profile_1.findProjectRoot)(root)).toBe(fs_1.default.realpathSync(root));
+    });
+    it('finds the root via .awm/profile.json', () => {
+        const root = tmpRoot();
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm', 'profile.json'), '{"extensions":[]}');
+        expect((0, profile_1.findProjectRoot)(root)).toBe(fs_1.default.realpathSync(root));
+    });
+    it('returns null when no marker is found up to the filesystem root', () => {
+        const root = tmpRoot(); // bare tmp dir, no markers
+        expect((0, profile_1.findProjectRoot)(root)).toBeNull();
+    });
+});
+describe('readProfile / writeProfile / addExtension', () => {
+    it('returns an empty profile when none exists', () => {
+        const root = tmpRoot();
+        expect((0, profile_1.readProfile)(root)).toEqual({ extensions: [] });
+    });
+    it('round-trips a written profile', () => {
+        const root = tmpRoot();
+        (0, profile_1.writeProfile)(root, { extensions: ['frontend'] });
+        expect((0, profile_1.readProfile)(root)).toEqual({ extensions: ['frontend'] });
+        expect(fs_1.default.existsSync(path_1.default.join(root, '.awm', 'profile.json'))).toBe(true);
+    });
+    it('addExtension appends and dedupes', () => {
+        const root = tmpRoot();
+        (0, profile_1.addExtension)(root, 'frontend');
+        (0, profile_1.addExtension)(root, 'frontend');
+        (0, profile_1.addExtension)(root, 'docs');
+        expect((0, profile_1.readProfile)(root).extensions).toEqual(['frontend', 'docs']);
+    });
+    it('tolerates a malformed extensions field', () => {
+        const root = tmpRoot();
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm', 'profile.json'), '{"extensions":"oops"}');
+        expect((0, profile_1.readProfile)(root)).toEqual({ extensions: [] });
+    });
+});
+describe('ensureProfile', () => {
+    it('creates an empty profile when none exists and reports it created one', () => {
+        const root = tmpRoot();
+        expect(fs_1.default.existsSync(path_1.default.join(root, '.awm', 'profile.json'))).toBe(false);
+        expect((0, profile_1.ensureProfile)(root)).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(root, '.awm', 'profile.json'))).toBe(true);
+        expect((0, profile_1.readProfile)(root)).toEqual({ extensions: [] });
+    });
+    it('is idempotent and preserves existing extensions', () => {
+        const root = tmpRoot();
+        (0, profile_1.addExtension)(root, 'frontend');
+        expect((0, profile_1.ensureProfile)(root)).toBe(false);
+        expect((0, profile_1.readProfile)(root).extensions).toEqual(['frontend']);
+    });
+});
+describe('ensureSkillsGitignored', () => {
+    it('appends the pattern when .gitignore is absent', () => {
+        const root = tmpRoot();
+        (0, profile_1.ensureSkillsGitignored)(root, ['claude-code']);
+        const gi = fs_1.default.readFileSync(path_1.default.join(root, '.gitignore'), 'utf-8');
+        expect(gi.split(/\r?\n/)).toContain('.claude/skills/');
+    });
+    it('is idempotent and preserves existing entries', () => {
+        const root = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root, '.gitignore'), 'node_modules\n');
+        (0, profile_1.ensureSkillsGitignored)(root, ['claude-code']);
+        (0, profile_1.ensureSkillsGitignored)(root, ['claude-code']);
+        const lines = fs_1.default.readFileSync(path_1.default.join(root, '.gitignore'), 'utf-8').split(/\r?\n/);
+        expect(lines).toContain('node_modules');
+        expect(lines.filter((l) => l.trim() === '.claude/skills/').length).toBe(1);
+    });
+    it('does not duplicate when the unslashed variant already exists', () => {
+        const root = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root, '.gitignore'), '.claude/skills\n');
+        (0, profile_1.ensureSkillsGitignored)(root, ['claude-code']);
+        const lines = fs_1.default.readFileSync(path_1.default.join(root, '.gitignore'), 'utf-8').split(/\r?\n/);
+        expect(lines.filter((l) => l.trim().startsWith('.claude/skills')).length).toBe(1);
+    });
+});
+describe('shouldRecordExtension', () => {
+    it('records only project-scope bundles installed locally', () => {
+        expect((0, profile_1.shouldRecordExtension)('project', 'local')).toBe(true);
+        expect((0, profile_1.shouldRecordExtension)('project', 'global')).toBe(false);
+        expect((0, profile_1.shouldRecordExtension)('baseline', 'global')).toBe(false);
+        expect((0, profile_1.shouldRecordExtension)('baseline', 'local')).toBe(false);
+        expect((0, profile_1.shouldRecordExtension)('ambient', 'global')).toBe(false);
+    });
+});

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

@@ -0,0 +1,52 @@
+"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-capability.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('capabilityRoot', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-capability-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-capability-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('devuelve el primer root configurado que tiene el dir pedido', () => {
+        const m = require('../../src/core/registries');
+        // dos registries en disco: 'a' sin hooks, 'b' con hooks
+        const aRoot = path_1.default.join(tmpHome, '.awm/registries/a');
+        const bRoot = path_1.default.join(tmpHome, '.awm/registries/b');
+        fs_1.default.mkdirSync(path_1.default.join(aRoot, 'skills'), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(bRoot, 'hooks'), { recursive: true });
+        m.writeRegistriesConfig([{ name: 'a', remote: 'x' }, { name: 'b', remote: 'y' }]);
+        expect(m.capabilityRoot('hooks')).toBe(bRoot);
+        expect(m.capabilityRoot('skills')).toBe(aRoot);
+    });
+    it('ningún root tiene el dir → null', () => {
+        const m = require('../../src/core/registries');
+        m.writeRegistriesConfig([]);
+        expect(m.capabilityRoot('hooks')).toBeNull();
+    });
+});