agentic-workflow-manager 2.0.0

package/dist/tests/core/diagnostics/checks.test.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const checks_1 = require("../../../src/core/diagnostics/checks");
+function healthyMachine() {
+    return {
+        registryCache: { present: true, gitState: 'clean' },
+        hook: { present: true, degraded: false },
+        devCore: { present: true, brokenLinks: [] },
+        ambient: { wanted: [], installed: [] },
+        contextInjection: [],
+        globalSkills: { valid: [], repairable: [], dead: [] },
+    };
+}
+function healthyProject() {
+    return {
+        root: '/repo/belanz',
+        profile: { present: true, extensions: ['frontend'] },
+        activeBundles: { expected: ['frontend-craft'], linked: ['frontend-craft'], broken: [] },
+        sensors: { present: true },
+        constitution: { present: true },
+        context: { present: true, file: 'CLAUDE.md' },
+    };
+}
+function byId(ctx, id) {
+    return (0, checks_1.runChecks)(ctx).results.find((r) => r.id === id);
+}
+describe('runChecks — overall', () => {
+    it('is healthy when machine is fully ok and there is no project', () => {
+        const report = (0, checks_1.runChecks)({ machine: healthyMachine(), project: null });
+        expect(report.overall).toBe('healthy');
+        expect(report.hasProject).toBe(false);
+        expect(report.projectName).toBeUndefined();
+    });
+    it('is healthy when machine and project are fully ok', () => {
+        const report = (0, checks_1.runChecks)({ machine: healthyMachine(), project: healthyProject() });
+        expect(report.overall).toBe('healthy');
+        expect(report.hasProject).toBe(true);
+        expect(report.projectName).toBe('belanz');
+    });
+    it('degrades when any check is missing', () => {
+        const m = healthyMachine();
+        m.hook.present = false;
+        expect((0, checks_1.runChecks)({ machine: m, project: null }).overall).toBe('degraded');
+    });
+    it('does NOT degrade on warn-only states', () => {
+        const m = healthyMachine();
+        m.registryCache.gitState = 'behind'; // warn
+        expect((0, checks_1.runChecks)({ machine: m, project: null }).overall).toBe('healthy');
+    });
+});
+describe('runChecks — machine.cli', () => {
+    it('ok when cache clean', () => {
+        const c = byId({ machine: healthyMachine(), project: null }, 'machine.cli');
+        expect(c.status).toBe('ok');
+        expect(c.label).toBe('CLI');
+        expect(c.remedy).toEqual({ kind: 'none' });
+    });
+    it('warn → awm update when behind', () => {
+        const m = healthyMachine();
+        m.registryCache.gitState = 'behind';
+        const c = byId({ machine: m, project: null }, 'machine.cli');
+        expect(c.status).toBe('warn');
+        expect(c.remedy).toEqual({ kind: 'command', value: 'awm update' });
+    });
+    it('warn + no action when dirty/unknown', () => {
+        const m = healthyMachine();
+        m.registryCache.gitState = 'dirty';
+        const c = byId({ machine: m, project: null }, 'machine.cli');
+        expect(c.status).toBe('warn');
+        expect(c.remedy).toEqual({ kind: 'none' });
+    });
+    it('missing → awm init when cache absent', () => {
+        const m = healthyMachine();
+        m.registryCache = { present: false };
+        const c = byId({ machine: m, project: null }, 'machine.cli');
+        expect(c.status).toBe('missing');
+        expect(c.remedy).toEqual({ kind: 'command', value: 'awm init' });
+    });
+});
+describe('runChecks — machine.hook / devCore', () => {
+    it('hook degraded → warn', () => {
+        const m = healthyMachine();
+        m.hook = { present: true, degraded: true };
+        expect(byId({ machine: m, project: null }, 'machine.hook').status).toBe('warn');
+    });
+    it('hook absent → missing + awm init', () => {
+        const m = healthyMachine();
+        m.hook = { present: false };
+        const c = byId({ machine: m, project: null }, 'machine.hook');
+        expect(c.status).toBe('missing');
+        expect(c.remedy).toEqual({ kind: 'command', value: 'awm init' });
+    });
+    it('devCore with broken links → warn', () => {
+        const m = healthyMachine();
+        m.devCore = { present: true, brokenLinks: ['brainstorming'] };
+        expect(byId({ machine: m, project: null }, 'machine.devCore').status).toBe('warn');
+    });
+    it('devCore absent → missing', () => {
+        const m = healthyMachine();
+        m.devCore = { present: false, brokenLinks: [] };
+        expect(byId({ machine: m, project: null }, 'machine.devCore').status).toBe('missing');
+    });
+});
+describe('runChecks — machine.ambient (dynamic)', () => {
+    it('emits no ambient rows when nothing is wanted', () => {
+        const report = (0, checks_1.runChecks)({ machine: healthyMachine(), project: null });
+        expect(report.results.some((r) => r.id.startsWith('machine.ambient.'))).toBe(false);
+    });
+    it('one row per wanted bundle, missing → awm add <b>', () => {
+        const m = healthyMachine();
+        m.ambient = { wanted: ['personal-notion', 'docs'], installed: ['docs'] };
+        const report = (0, checks_1.runChecks)({ machine: m, project: null });
+        const notion = report.results.find((r) => r.id === 'machine.ambient.personal-notion');
+        const docs = report.results.find((r) => r.id === 'machine.ambient.docs');
+        expect(notion.status).toBe('missing');
+        expect(notion.remedy).toEqual({ kind: 'command', value: 'awm add personal-notion' });
+        expect(docs.status).toBe('ok');
+        expect(report.overall).toBe('degraded');
+    });
+});
+describe('runChecks — project', () => {
+    it('omits project checks when project is null', () => {
+        const report = (0, checks_1.runChecks)({ machine: healthyMachine(), project: null });
+        expect(report.results.some((r) => r.level === 'project')).toBe(false);
+    });
+    it('constitution absent → missing + skill remedy (degrades)', () => {
+        const p = healthyProject();
+        p.constitution = { present: false };
+        const report = (0, checks_1.runChecks)({ machine: healthyMachine(), project: p });
+        const c = report.results.find((r) => r.id === 'project.constitution');
+        expect(c.status).toBe('missing');
+        expect(c.remedy).toEqual({ kind: 'skill', value: 'project-constitution' });
+        expect(report.overall).toBe('degraded');
+    });
+    it('context absent → warn + skill remedy (does NOT degrade)', () => {
+        const p = healthyProject();
+        p.context = { present: false };
+        const report = (0, checks_1.runChecks)({ machine: healthyMachine(), project: p });
+        const c = report.results.find((r) => r.id === 'project.context');
+        expect(c.status).toBe('warn');
+        expect(c.label).toBe('contexto del agente (CLAUDE.md/AGENTS.md) ausente');
+        expect(c.remedy).toEqual({ kind: 'skill', value: 'project-context-init' });
+        expect(report.overall).toBe('healthy');
+    });
+    it('activation with missing links → missing + awm sync', () => {
+        const p = healthyProject();
+        p.activeBundles = { expected: ['frontend-craft', 'impeccable'], linked: ['frontend-craft'], broken: [] };
+        const c = (0, checks_1.runChecks)({ machine: healthyMachine(), project: p }).results.find((r) => r.id === 'project.activation');
+        expect(c.status).toBe('missing');
+        expect(c.remedy).toEqual({ kind: 'command', value: 'awm sync' });
+    });
+    it('sensors absent → missing + awm sensors init', () => {
+        const p = healthyProject();
+        p.sensors = { present: false };
+        const c = (0, checks_1.runChecks)({ machine: healthyMachine(), project: p }).results.find((r) => r.id === 'project.sensors');
+        expect(c.status).toBe('missing');
+        expect(c.remedy).toEqual({ kind: 'command', value: 'awm sensors init' });
+    });
+});
+describe('machineChecks — global skill integrity', () => {
+    function machineCtx(globalSkills) {
+        return {
+            machine: {
+                registryCache: { present: true, gitState: 'clean' },
+                hook: { present: true, degraded: false },
+                devCore: { present: true, brokenLinks: [] },
+                ambient: { wanted: [], installed: [] },
+                contextInjection: [],
+                globalSkills,
+            },
+            project: null,
+        };
+    }
+    it('ok when no broken global skill links', () => {
+        const report = (0, checks_1.runChecks)(machineCtx({ valid: ['a'], repairable: [], dead: [] }));
+        const row = report.results.find((r) => r.id === 'machine.globalSkills');
+        expect(row?.status).toBe('ok');
+    });
+    it('warns with awm init remedy when there are broken links', () => {
+        const report = (0, checks_1.runChecks)(machineCtx({ valid: ['a'], repairable: ['b'], dead: ['c'] }));
+        const row = report.results.find((r) => r.id === 'machine.globalSkills');
+        expect(row?.status).toBe('warn');
+        expect(row?.detail).toContain('2'); // 1 repairable + 1 dead
+        expect(row?.remedy).toEqual({ kind: 'command', value: 'awm init' });
+    });
+});
+describe('machine.context.<agent> checks', () => {
+    function machineWith(contextInjection) {
+        return { ...healthyMachine(), contextInjection };
+    }
+    it('ok when context is injected for an agent', () => {
+        const r = (0, checks_1.runChecks)({ machine: machineWith([{ agent: 'opencode', state: 'injected' }]), project: null });
+        const row = r.results.find((x) => x.id === 'machine.context.opencode');
+        expect(row.status).toBe('ok');
+        expect(row.remedy).toEqual({ kind: 'none' });
+    });
+    it('missing + awm init remedy when absent (degrades overall)', () => {
+        const r = (0, checks_1.runChecks)({ machine: machineWith([{ agent: 'opencode', state: 'absent' }]), project: null });
+        const row = r.results.find((x) => x.id === 'machine.context.opencode');
+        expect(row.status).toBe('missing');
+        expect(row.remedy).toEqual({ kind: 'command', value: 'awm init' });
+        expect(r.overall).toBe('degraded');
+    });
+    it('warn when stale', () => {
+        const r = (0, checks_1.runChecks)({ machine: machineWith([{ agent: 'claude-code', state: 'stale' }]), project: null });
+        expect(r.results.find((x) => x.id === 'machine.context.claude-code').status).toBe('warn');
+    });
+});

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

@@ -0,0 +1,170 @@
+"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"));
+function bundle(name, scope, skills) {
+    return {
+        name, description: '', version: '1.0.0', scope, visibility: 'public',
+        dependsOn: [], skills: skills.map((s) => ({ name: s, onSignal: false })),
+        workflows: [], agents: [],
+    };
+}
+describe('gatherContext', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-doctor-'));
+        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;
+    });
+    // Crea un symlink "vivo" <claudeSkills>/<skill> → un target real.
+    function linkGlobalSkill(skill) {
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        const target = path_1.default.join(tmpHome, 'targets', skill);
+        fs_1.default.mkdirSync(target, { recursive: true });
+        fs_1.default.symlinkSync(target, path_1.default.join(skillsDir, skill), 'dir');
+    }
+    it('machine: cli/hook/devCore absent on a bare HOME', () => {
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [bundle('dev-core', 'baseline', ['brainstorming'])] });
+        expect(ctx.machine.registryCache.present).toBe(false);
+        expect(ctx.machine.hook.present).toBe(false);
+        expect(ctx.machine.devCore.present).toBe(false);
+        expect(ctx.machine.ambient.wanted).toEqual([]);
+    });
+    it('machine: devCore present when baseline skills are linked globally', () => {
+        linkGlobalSkill('brainstorming');
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [bundle('dev-core', 'baseline', ['brainstorming'])] });
+        expect(ctx.machine.devCore.present).toBe(true);
+        expect(ctx.machine.devCore.brokenLinks).toEqual([]);
+    });
+    it('machine: partial install (some absent, not dangling) surfaces absent skills in brokenLinks', () => {
+        linkGlobalSkill('brainstorming'); // only 1 of 2 skills linked
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [bundle('dev-core', 'baseline', ['brainstorming', 'another-skill'])] });
+        expect(ctx.machine.devCore.present).toBe(true);
+        expect(ctx.machine.devCore.brokenLinks).toContain('another-skill');
+    });
+    it('machine: reports a broken dev-core symlink', () => {
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        fs_1.default.symlinkSync(path_1.default.join(tmpHome, 'targets', 'gone'), path_1.default.join(skillsDir, 'brainstorming'), 'dir');
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [bundle('dev-core', 'baseline', ['brainstorming'])] });
+        expect(ctx.machine.devCore.present).toBe(true);
+        expect(ctx.machine.devCore.brokenLinks).toContain('brainstorming');
+    });
+    it('machine: ambient wanted read from ~/.awm/config.json, installed reflects links', () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'config.json'), JSON.stringify({ ambient: ['personal-notion'] }));
+        linkGlobalSkill('notion-skill');
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const bundles = [
+            bundle('dev-core', 'baseline', ['brainstorming']),
+            bundle('personal-notion', 'ambient', ['notion-skill']),
+        ];
+        const ctx = gatherContext({ cwd: tmpHome, bundles });
+        expect(ctx.machine.ambient.wanted).toEqual(['personal-notion']);
+        expect(ctx.machine.ambient.installed).toEqual(['personal-notion']);
+    });
+    it('machine: contextInjection empty when opencode config is absent', () => {
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [] });
+        // sin ~/.config/opencode/opencode.json no se reporta ninguna fila de contexto
+        expect(ctx.machine.contextInjection).toEqual([]);
+    });
+    it('machine: contextInjection reports opencode absent when config exists without the sentinel', () => {
+        const ocDir = path_1.default.join(tmpHome, '.config', 'opencode');
+        fs_1.default.mkdirSync(ocDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(ocDir, 'opencode.json'), JSON.stringify({ $schema: 'https://opencode.ai/config.json', instructions: [] }));
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [] });
+        expect(ctx.machine.contextInjection).toEqual([{ agent: 'opencode', state: 'absent' }]);
+    });
+    it('project: null when cwd has no project root', () => {
+        // tmpHome is bare (no .git / package.json / .awm/profile.json)
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [] });
+        expect(ctx.project).toBeNull();
+    });
+    it('project: maps profile, activation, sensors, constitution and context', () => {
+        const root = path_1.default.join(tmpHome, 'repo');
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}'); // project root marker
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm', 'profile.json'), JSON.stringify({ extensions: ['frontend'] }));
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm', 'sensors.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'CONSTITUTION.md'), '# rules');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'AGENTS.md'), '# agents');
+        // link the expected project skill locally
+        const localSkills = path_1.default.join(root, '.claude', 'skills');
+        fs_1.default.mkdirSync(localSkills, { recursive: true });
+        const target = path_1.default.join(root, 'targets', 'frontend-craft');
+        fs_1.default.mkdirSync(target, { recursive: true });
+        fs_1.default.symlinkSync(target, path_1.default.join(localSkills, 'frontend-craft'), 'dir');
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: root, bundles: [bundle('frontend', 'project', ['frontend-craft'])] });
+        expect(ctx.project).not.toBeNull();
+        expect(ctx.project.profile).toEqual({ present: true, extensions: ['frontend'] });
+        expect(ctx.project.activeBundles.expected).toEqual(['frontend-craft']);
+        expect(ctx.project.activeBundles.linked).toEqual(['frontend-craft']);
+        expect(ctx.project.activeBundles.broken).toEqual([]);
+        expect(ctx.project.sensors.present).toBe(true);
+        expect(ctx.project.constitution.present).toBe(true);
+        expect(ctx.project.context).toEqual({ present: true, file: 'AGENTS.md' });
+    });
+    it('project: context prefers CLAUDE.md over AGENTS.md', () => {
+        const root = path_1.default.join(tmpHome, 'repo2');
+        fs_1.default.mkdirSync(root, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'CLAUDE.md'), '# claude');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'AGENTS.md'), '# agents');
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: root, bundles: [] });
+        expect(ctx.project.context).toEqual({ present: true, file: 'CLAUDE.md' });
+    });
+});
+describe('gatherMachine — agnostic skill health (#4)', () => {
+    it('classifies the target agent skills dir, not always Claude', () => {
+        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 { gatherContext } = require('../../../src/core/diagnostics/context');
+            // OpenCode skills dir gets a dangling symlink (not in the registry) → 'dead'.
+            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 oc = gatherContext({ cwd: home, bundles: [], agent: 'opencode' });
+            expect(oc.machine.globalSkills.dead).toContain('ghost');
+            // Claude's dir is empty → its 'dead' list must NOT pick up OpenCode's orphan.
+            const cc = gatherContext({ cwd: home, bundles: [], agent: 'claude-code' });
+            expect(cc.machine.globalSkills.dead).not.toContain('ghost');
+        }
+        finally {
+            process.env.HOME = prevHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
+});

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

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+function writeSkill(root, name) {
+    const dir = path_1.default.join(root, 'skills', name);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), `---\nname: ${name}\ndescription: d-${name}\n---\n`);
+}
+function writeWorkflow(root, name) {
+    const dir = path_1.default.join(root, 'workflows');
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, `${name}.md`), `---\nname: ${name}\ndescription: w-${name}\n---\n`);
+}
+describe('discovery multi-root', () => {
+    let tmp;
+    let rootA;
+    let rootB;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-disc-'));
+        rootA = path_1.default.join(tmp, 'a');
+        rootB = path_1.default.join(tmp, 'b');
+        fs_1.default.mkdirSync(rootA, { recursive: true });
+        fs_1.default.mkdirSync(rootB, { recursive: true });
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('merges skills from multiple roots, each keeping its absolute path', () => {
+        writeSkill(rootA, 'alpha');
+        writeSkill(rootB, 'beta');
+        const { discoverSkills } = require('../../src/core/discovery');
+        const skills = discoverSkills([rootA, rootB]);
+        expect(skills.map((s) => s.name).sort()).toEqual(['alpha', 'beta']);
+        expect(skills.find((s) => s.name === 'beta').path).toBe(path_1.default.join(rootB, 'skills', 'beta'));
+    });
+    it('throws an explicit error naming BOTH sources on skill name collision', () => {
+        writeSkill(rootA, 'dup');
+        writeSkill(rootB, 'dup');
+        const { discoverSkills } = require('../../src/core/discovery');
+        expect(() => discoverSkills([rootA, rootB])).toThrow(new RegExp(`dup.*${path_1.default.join(rootA, 'skills', 'dup').replace(/[/\\]/g, '.')}.*${path_1.default.join(rootB, 'skills', 'dup').replace(/[/\\]/g, '.')}`));
+    });
+    it('merges workflows from multiple roots and detects collisions', () => {
+        writeWorkflow(rootA, 'flow');
+        const { discoverWorkflows } = require('../../src/core/discovery');
+        expect(discoverWorkflows([rootA, rootB]).map((w) => w.name)).toEqual(['flow']);
+        writeWorkflow(rootB, 'flow');
+        jest.resetModules();
+        const fresh = require('../../src/core/discovery');
+        expect(() => fresh.discoverWorkflows([rootA, rootB])).toThrow(/collision/i);
+    });
+    it('skips roots without the artifact dir', () => {
+        writeSkill(rootA, 'alpha');
+        const { discoverSkills, discoverAgents } = require('../../src/core/discovery');
+        expect(discoverSkills([rootA, rootB]).length).toBe(1);
+        expect(discoverAgents([rootA, rootB])).toEqual([]);
+    });
+});

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

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+function writeSkill(root, name) {
+    const dir = path_1.default.join(root, 'skills', name);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), `---\nname: ${name}\ndescription: d\n---\n`);
+}
+function writeWorkflow(root, name) {
+    fs_1.default.mkdirSync(path_1.default.join(root, 'workflows'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'workflows', `${name}.md`), `---\ndescription: d\n---\n`);
+}
+function writeAgent(root, name) {
+    fs_1.default.mkdirSync(path_1.default.join(root, 'agents'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'agents', `${name}.md`), `---\ndescription: d\n---\n`);
+}
+function writeManifest(root, overrides) {
+    fs_1.default.mkdirSync(root, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({ overrides }));
+}
+describe('discovery override resolution', () => {
+    let tmp;
+    let rootA;
+    let rootB;
+    let rootC;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-disc-ovr-'));
+        rootA = path_1.default.join(tmp, 'a');
+        rootB = path_1.default.join(tmp, 'b');
+        rootC = path_1.default.join(tmp, 'c');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    function load() {
+        return require('../../src/core/discovery');
+    }
+    it('declared override: later root wins and records provenance', () => {
+        writeSkill(rootA, 'brainstorming');
+        writeSkill(rootB, 'brainstorming');
+        writeManifest(rootB, ['brainstorming']);
+        const { discoverSkills } = load();
+        const out = discoverSkills([rootA, rootB]);
+        expect(out).toHaveLength(1);
+        expect(out[0].path).toBe(path_1.default.join(rootB, 'skills', 'brainstorming'));
+        expect(out[0].overrode).toBe(path_1.default.join(rootA, 'skills', 'brainstorming'));
+    });
+    it('undeclared collision still throws naming both sources', () => {
+        writeSkill(rootA, 'dup');
+        writeSkill(rootB, 'dup');
+        const { discoverSkills } = load();
+        expect(() => discoverSkills([rootA, rootB])).toThrow(/dup/);
+        expect(() => discoverSkills([rootA, rootB])).toThrow(new RegExp(rootA.replace(/[/\\]/g, '.')));
+    });
+    it('orphan override (no collision) is not an error', () => {
+        writeSkill(rootB, 'only-here');
+        writeManifest(rootB, ['renamed-upstream-skill']);
+        const { discoverSkills } = load();
+        const out = discoverSkills([rootB]);
+        expect(out).toHaveLength(1);
+        expect(out[0].overrode).toBeUndefined();
+    });
+    it('chain: two registries both declaring the same name — last in order wins', () => {
+        writeSkill(rootA, 'x');
+        writeSkill(rootB, 'x');
+        writeSkill(rootC, 'x');
+        writeManifest(rootB, ['x']);
+        writeManifest(rootC, ['x']);
+        const { discoverSkills } = load();
+        const out = discoverSkills([rootA, rootB, rootC]);
+        expect(out).toHaveLength(1);
+        expect(out[0].path).toBe(path_1.default.join(rootC, 'skills', 'x'));
+        expect(out[0].overrode).toBe(path_1.default.join(rootB, 'skills', 'x'));
+    });
+    it('workflows: declared override wins, undeclared throws', () => {
+        writeWorkflow(rootA, 'flow');
+        writeWorkflow(rootB, 'flow');
+        const { discoverWorkflows } = load();
+        expect(() => discoverWorkflows([rootA, rootB])).toThrow(/flow/);
+        writeManifest(rootB, ['flow']);
+        jest.resetModules();
+        const out = load().discoverWorkflows([rootA, rootB]);
+        expect(out).toHaveLength(1);
+        expect(out[0].path).toBe(path_1.default.join(rootB, 'workflows', 'flow.md'));
+        expect(out[0].overrode).toBe(path_1.default.join(rootA, 'workflows', 'flow.md'));
+    });
+    it('agents: declared override wins, undeclared throws', () => {
+        writeAgent(rootA, 'bot');
+        writeAgent(rootB, 'bot');
+        const { discoverAgents } = load();
+        expect(() => discoverAgents([rootA, rootB])).toThrow(/bot/);
+        writeManifest(rootB, ['bot']);
+        jest.resetModules();
+        const out = load().discoverAgents([rootA, rootB]);
+        expect(out).toHaveLength(1);
+        expect(out[0].path).toBe(path_1.default.join(rootB, 'agents', 'bot.md'));
+        expect(out[0].overrode).toBe(path_1.default.join(rootA, 'agents', 'bot.md'));
+    });
+});

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

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const discovery_1 = require("../../src/core/discovery");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+jest.mock('fs');
+// Fixed roots used in unit tests — these are passed explicitly to discoverSkills/
+// discoverWorkflows, which append 'skills'/'workflows' subdirectories internally.
+const CONTENT_ROOT = '/fake/registry';
+const SKILLS_ROOT = CONTENT_ROOT;
+const WORKFLOWS_ROOT = CONTENT_ROOT;
+// For backward-compat with mock expectations that check SKILLS_DIR-style paths:
+const SKILLS_DIR = path_1.default.join(CONTENT_ROOT, 'skills');
+const WORKFLOWS_DIR = path_1.default.join(CONTENT_ROOT, 'workflows');
+describe('Artifact Discovery', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('discoverSkills', () => {
+        it('should return a list of skill directories that contain a SKILL.md', () => {
+            fs_1.default.existsSync.mockImplementation((p) => {
+                if (p === SKILLS_DIR)
+                    return true;
+                if (p.endsWith('SKILL.md'))
+                    return true;
+                return false;
+            });
+            fs_1.default.readdirSync.mockReturnValue([
+                { name: 'my-skill', isDirectory: () => true },
+                { name: 'another-skill', isDirectory: () => true },
+                { name: 'readme.txt', isDirectory: () => false },
+            ]);
+            const skills = (0, discovery_1.discoverSkills)([SKILLS_ROOT]);
+            expect(skills).toHaveLength(2);
+            expect(skills[0].name).toBe('my-skill');
+            expect(skills[1].name).toBe('another-skill');
+            expect(skills[0].description).toBe('');
+        });
+        it('should return an empty array if the skills directory does not exist', () => {
+            fs_1.default.existsSync.mockReturnValue(false);
+            const skills = (0, discovery_1.discoverSkills)([SKILLS_ROOT]);
+            expect(skills).toEqual([]);
+        });
+        it('should skip skill directories without a SKILL.md', () => {
+            fs_1.default.existsSync.mockImplementation((p) => {
+                if (p === SKILLS_DIR)
+                    return true;
+                // This skill has no SKILL.md
+                if (p.endsWith('SKILL.md'))
+                    return false;
+                return false;
+            });
+            fs_1.default.readdirSync.mockReturnValue([
+                { name: 'broken-skill', isDirectory: () => true },
+            ]);
+            const skills = (0, discovery_1.discoverSkills)([SKILLS_ROOT]);
+            expect(skills).toEqual([]);
+        });
+    });
+    describe('discoverWorkflows', () => {
+        it('should return a list of .md files in the workflows directory', () => {
+            fs_1.default.existsSync.mockImplementation((p) => {
+                if (p.endsWith('awm-registry.json'))
+                    return false;
+                return true;
+            });
+            fs_1.default.readdirSync.mockReturnValue([
+                { name: 'deploy.md', isDirectory: () => false },
+                { name: 'ci.md', isDirectory: () => false },
+                { name: 'readme.txt', isDirectory: () => false },
+            ]);
+            const workflows = (0, discovery_1.discoverWorkflows)([WORKFLOWS_ROOT]);
+            expect(workflows).toHaveLength(2);
+            expect(workflows[0].name).toBe('deploy');
+            expect(workflows[1].name).toBe('ci');
+            expect(workflows[0].description).toBe('');
+        });
+        it('should return an empty array if the workflows directory does not exist', () => {
+            fs_1.default.existsSync.mockReturnValue(false);
+            const workflows = (0, discovery_1.discoverWorkflows)([WORKFLOWS_ROOT]);
+            expect(workflows).toEqual([]);
+        });
+    });
+    describe('readArtifactDescription', () => {
+        it('extracts the description field from YAML frontmatter', () => {
+            fs_1.default.readFileSync.mockReturnValue('---\nname: my-skill\ndescription: Does a useful thing\n---\n\n# Body\n');
+            expect((0, discovery_1.readArtifactDescription)('/any/SKILL.md')).toBe('Does a useful thing');
+        });
+        it('strips surrounding quotes from the description', () => {
+            fs_1.default.readFileSync.mockReturnValue('---\ndescription: "Quoted desc"\n---\n');
+            expect((0, discovery_1.readArtifactDescription)('/any/SKILL.md')).toBe('Quoted desc');
+        });
+        it('returns empty string when there is no frontmatter', () => {
+            fs_1.default.readFileSync.mockReturnValue('# Just a heading\n');
+            expect((0, discovery_1.readArtifactDescription)('/any/SKILL.md')).toBe('');
+        });
+        it('returns empty string when description is absent', () => {
+            fs_1.default.readFileSync.mockReturnValue('---\nname: x\n---\n');
+            expect((0, discovery_1.readArtifactDescription)('/any/SKILL.md')).toBe('');
+        });
+        it('returns empty string when the file cannot be read', () => {
+            fs_1.default.readFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+            expect((0, discovery_1.readArtifactDescription)('/missing/SKILL.md')).toBe('');
+        });
+        it('returns empty string for a block scalar description indicator', () => {
+            fs_1.default.readFileSync.mockReturnValue('---\ndescription: >-\n  actual text\n---\n');
+            expect((0, discovery_1.readArtifactDescription)('/any/SKILL.md')).toBe('');
+        });
+    });
+});