agentic-workflow-manager 2.0.0

package/dist/tests/integration/pack-e2e.test.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/integration/pack-e2e.test.ts
+//
+// Verifica el criterio del roadmap sin publicar: el tarball de npm pack corre
+// `awm update` end-to-end contra un registry fixture, sin el monorepo.
+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' });
+jest.setTimeout(180_000);
+it('el tarball empaquetado corre awm update sin el monorepo', () => {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pack-'));
+    const cliDir = path_1.default.resolve(__dirname, '../..');
+    try {
+        (0, child_process_1.execSync)(`npm pack --pack-destination "${tmp}"`, { cwd: cliDir, stdio: 'pipe' });
+        const tarball = fs_1.default.readdirSync(tmp).find((f) => f.endsWith('.tgz'));
+        (0, child_process_1.execSync)(`tar -xzf "${tarball}"`, { cwd: tmp });
+        const pkgDir = path_1.default.join(tmp, 'package');
+        // files whitelist: dist viaja, src no
+        expect(fs_1.default.existsSync(path_1.default.join(pkgDir, 'dist/src/index.js'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(pkgDir, 'src'))).toBe(false);
+        // deps sin red: el node_modules del repo sirve al binario extraído
+        fs_1.default.symlinkSync(path_1.default.join(cliDir, 'node_modules'), path_1.default.join(pkgDir, 'node_modules'));
+        // registry fixture con un skill y tag v1.0.0
+        const source = path_1.default.join(tmp, 'src-reg');
+        fs_1.default.mkdirSync(path_1.default.join(source, 'skills/alpha'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(source, 'skills/alpha/SKILL.md'), '---\nname: alpha\ndescription: t\n---\n');
+        GIT(source, 'init -q');
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm init');
+        GIT(source, 'tag v1.0.0');
+        const home = path_1.default.join(tmp, 'home');
+        const awmHome = path_1.default.join(home, '.awm');
+        fs_1.default.mkdirSync(awmHome, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: source }]));
+        (0, child_process_1.execSync)(`node "${path_1.default.join(pkgDir, 'dist/src/index.js')}" update`, {
+            env: { ...process.env, HOME: home, AWM_HOME: awmHome, AWM_NO_UPDATE_CHECK: '1' },
+            stdio: 'pipe',
+        });
+        expect(fs_1.default.existsSync(path_1.default.join(awmHome, 'registries/baseline/skills/alpha/SKILL.md'))).toBe(true);
+    }
+    finally {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    }
+});

package/dist/tests/providers/hooks-config.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const providers_1 = require("../../src/providers");
+describe('Hook configuration in providers', () => {
+    it('claude-code provider defines a HookConfig', () => {
+        const cc = providers_1.PROVIDERS['claude-code'];
+        expect(cc.hooks).toBeDefined();
+        expect(cc.hooks?.type).toBe('cc-settings-merge');
+        expect(cc.hooks?.eventName).toBe('SessionStart');
+        expect(cc.hooks?.matcher).toBe('startup|clear|compact');
+    });
+    it('claude-code settingsPath resolves to ~/.claude/settings.json', () => {
+        const cc = providers_1.PROVIDERS['claude-code'];
+        expect(cc.hooks?.settingsPath).toMatch(/\.claude\/settings\.json$/);
+    });
+    it('claude-code scriptsDir resolves to ~/.awm/hooks/', () => {
+        const cc = providers_1.PROVIDERS['claude-code'];
+        expect(cc.hooks?.scriptsDir).toMatch(/\.awm\/hooks$/);
+    });
+    it('antigravity and opencode have no hooks (single-harness scope)', () => {
+        expect(providers_1.PROVIDERS['antigravity'].hooks).toBeUndefined();
+        expect(providers_1.PROVIDERS['opencode'].hooks).toBeUndefined();
+    });
+    it('getHookConfig returns config for supported target', () => {
+        const config = (0, providers_1.getHookConfig)('claude-code');
+        expect(config).toBeDefined();
+        expect(config?.type).toBe('cc-settings-merge');
+    });
+    it('getHookConfig returns undefined for unsupported target', () => {
+        const config = (0, providers_1.getHookConfig)('antigravity');
+        expect(config).toBeUndefined();
+    });
+    it('respects AWM_HOME env var override for scriptsDir', () => {
+        const originalEnv = process.env.AWM_HOME;
+        process.env.AWM_HOME = '/tmp/awm-test';
+        // Re-import to pick up env change
+        jest.resetModules();
+        const { PROVIDERS: P } = require('../../src/providers');
+        expect(P['claude-code'].hooks.scriptsDir).toBe('/tmp/awm-test/hooks');
+        if (originalEnv === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalEnv;
+    });
+});

package/dist/tests/providers/index.test.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/providers/index.test.ts
+const providers_1 = require("../../src/providers");
+const os_1 = __importDefault(require("os"));
+describe('Providers Routing', () => {
+    // ── Existing Antigravity tests (preserved) ──
+    it('routes antigravity global skills correctly', () => {
+        const result = (0, providers_1.getTargetPath)('skill', 'antigravity', 'global');
+        expect(result).toBe(`${os_1.default.homedir()}/.gemini/antigravity/skills`);
+    });
+    it('routes opencode local skills correctly', () => {
+        const result = (0, providers_1.getTargetPath)('skill', 'opencode', 'local');
+        expect(result).toBe('.agents/skills');
+    });
+    it('routes antigravity global workflows correctly', () => {
+        const result = (0, providers_1.getTargetPath)('workflow', 'antigravity', 'global');
+        expect(result).toBe(`${os_1.default.homedir()}/.gemini/antigravity/global_workflows`);
+    });
+    it('throws on opencode workflow', () => {
+        expect(() => (0, providers_1.getTargetPath)('workflow', 'opencode', 'global')).toThrow('not supported');
+    });
+    // ── New Claude Code tests ──
+    it('routes claude-code global skills correctly', () => {
+        const result = (0, providers_1.getTargetPath)('skill', 'claude-code', 'global');
+        expect(result).toBe(`${os_1.default.homedir()}/.claude/skills`);
+    });
+    it('routes claude-code local skills correctly', () => {
+        const result = (0, providers_1.getTargetPath)('skill', 'claude-code', 'local');
+        expect(result).toBe('.claude/skills');
+    });
+    it('routes claude-code global agents correctly', () => {
+        const result = (0, providers_1.getTargetPath)('agent', 'claude-code', 'global');
+        expect(result).toBe(`${os_1.default.homedir()}/.claude/agents`);
+    });
+    it('routes claude-code local agents correctly', () => {
+        const result = (0, providers_1.getTargetPath)('agent', 'claude-code', 'local');
+        expect(result).toBe('.claude/agents');
+    });
+    it('throws on claude-code workflow', () => {
+        expect(() => (0, providers_1.getTargetPath)('workflow', 'claude-code', 'global')).toThrow('not supported');
+    });
+    it('throws on unknown agent target', () => {
+        expect(() => (0, providers_1.getTargetPath)('skill', 'unknown-agent', 'global')).toThrow('Unknown agent target');
+    });
+    // ── PROVIDERS map structure tests ──
+    it('exports PROVIDERS with all three targets', () => {
+        expect(Object.keys(providers_1.PROVIDERS)).toEqual(expect.arrayContaining(['antigravity', 'opencode', 'claude-code']));
+    });
+    it('marks unsupported artifact types as null', () => {
+        expect(providers_1.PROVIDERS['antigravity'].agent).toBeNull();
+        expect(providers_1.PROVIDERS['opencode'].workflow).toBeNull();
+        expect(providers_1.PROVIDERS['claude-code'].workflow).toBeNull();
+    });
+});

package/dist/tests/providers/injection-config.test.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../src/providers");
+describe('getInjection', () => {
+    it('returns cc-settings-merge for claude-code', () => {
+        const inj = (0, providers_1.getInjection)('claude-code');
+        expect(inj?.type).toBe('cc-settings-merge');
+    });
+    it('returns config-instructions for opencode pointing at the global opencode.json', () => {
+        const inj = (0, providers_1.getInjection)('opencode');
+        expect(inj).toEqual({
+            type: 'config-instructions',
+            configPath: path_1.default.join(os_1.default.homedir(), '.config/opencode/opencode.json'),
+            field: 'instructions',
+        });
+    });
+    it('returns undefined for antigravity (no injection mechanism wired yet)', () => {
+        expect((0, providers_1.getInjection)('antigravity')).toBeUndefined();
+    });
+});

package/dist/tests/registry/b3-ledger-wiring.test.js

@@ -0,0 +1,74 @@
+"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 REG = path_1.default.join(__dirname, '../../../registry/skills');
+const read = (p) => fs_1.default.readFileSync(path_1.default.join(REG, p), 'utf-8');
+describe('B-3 harness-retro is ledger-driven', () => {
+    const skill = read('harness-retro/SKILL.md');
+    test('reads the ledger via awm ledger list + recurring', () => {
+        expect(skill).toMatch(/awm ledger list/);
+        expect(skill).toMatch(/awm ledger recurring/);
+    });
+    test('archives the ledger when done', () => {
+        expect(skill).toMatch(/awm ledger archive/);
+    });
+    test('no longer relies on the human "where did this fail before?" memory step', () => {
+        expect(skill).not.toMatch(/Where did this pattern fail before\?/);
+    });
+    test('cures into AGENTS.md (agnostic) for agent-style lessons + wins, not CLAUDE.md', () => {
+        expect(skill).toMatch(/AGENTS\.md/);
+    });
+    test('writes the awm-retro-complete marker', () => {
+        expect(skill).toMatch(/awm-retro-complete/);
+    });
+    test('treats recurrence as a signal, not a hard >=2 gate (interactive decision)', () => {
+        expect(skill).toMatch(/se(ñ|n)al|signal/i);
+    });
+});
+describe('B-3 capture wiring — phases append to the ledger', () => {
+    test('SDD spec reviewer emits findings AND wins to the ledger', () => {
+        const p = read('subagent-driven-development/spec-reviewer-prompt.md');
+        expect(p).toMatch(/awm ledger add/);
+        expect(p).toMatch(/--polarity finding/);
+        expect(p).toMatch(/--polarity win/);
+    });
+    test('SDD code-quality reviewer emits findings AND wins to the ledger', () => {
+        const p = read('subagent-driven-development/code-quality-reviewer-prompt.md');
+        expect(p).toMatch(/awm ledger add/);
+        expect(p).toMatch(/--polarity win/);
+    });
+    test('post-qa deep-review emits findings AND wins to the ledger', () => {
+        const p = read('post-implementation-qa/deep-review-prompt.md');
+        expect(p).toMatch(/awm ledger add/);
+        expect(p).toMatch(/--polarity win/);
+    });
+    test('verification-before-completion logs recurring sensor failures', () => {
+        const p = read('verification-before-completion/SKILL.md');
+        expect(p).toMatch(/awm ledger add/);
+    });
+    test('systematic-debugging logs the confirmed root cause', () => {
+        const p = read('systematic-debugging/SKILL.md');
+        expect(p).toMatch(/awm ledger add/);
+    });
+});
+describe('B-3 development-process routes harness-retro as a terminal phase', () => {
+    const skill = read('development-process/SKILL.md');
+    test('harness-retro appears as a pipeline phase between QA and finishing', () => {
+        const qaIdx = skill.indexOf('post-implementation-qa');
+        const retroIdx = skill.indexOf('harness-retro');
+        const finishIdx = skill.indexOf('finishing-a-development-branch');
+        expect(retroIdx).toBeGreaterThan(-1);
+        expect(qaIdx).toBeLessThan(retroIdx);
+        expect(retroIdx).toBeLessThan(finishIdx);
+        // Also assert the routing edge exists (not just node declarations)
+        expect(skill).toMatch(/post-implementation-qa.*harness-retro|harness-retro.*post-implementation-qa/s);
+        expect(skill).toMatch(/harness-retro.*finishing-a-development-branch|finishing-a-development-branch.*harness-retro/s);
+    });
+    test('routing keys on the awm-retro-complete marker', () => {
+        expect(skill).toMatch(/awm-retro-complete/);
+    });
+});

package/dist/tests/registry/catalog-consistency.test.js

@@ -0,0 +1,47 @@
+"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 CONTENT = path_1.default.join(__dirname, '../../../registry');
+function readJson(p) { return JSON.parse(fs_1.default.readFileSync(p, 'utf-8')); }
+describe('catalog/bundle consistency', () => {
+    const catalog = readJson(path_1.default.join(CONTENT, 'catalog.json'));
+    it('declares exactly the 4 bundles', () => {
+        expect(catalog.bundles.map((b) => b.name).sort())
+            .toEqual(['authoring', 'dev', 'docs', 'frontend']);
+    });
+    it('every catalog entry has a matching bundle.json whose mirrored fields agree', () => {
+        for (const entry of catalog.bundles) {
+            const manifest = readJson(path_1.default.join(CONTENT, entry.source, 'bundle.json'));
+            expect(manifest.name).toBe(entry.name);
+            expect(manifest.scope).toBe(entry.scope);
+            expect(manifest.version).toBe(entry.version);
+            expect(manifest.visibility ?? 'public').toBe(entry.visibility ?? 'public');
+        }
+    });
+    it('every referenced skill exists in registry/skills', () => {
+        for (const entry of catalog.bundles) {
+            const manifest = readJson(path_1.default.join(CONTENT, entry.source, 'bundle.json'));
+            for (const s of manifest.skills) {
+                const name = typeof s === 'string' ? s : s.name;
+                expect(fs_1.default.existsSync(path_1.default.join(CONTENT, 'skills', name, 'SKILL.md'))).toBe(true);
+            }
+        }
+    });
+    it('bundle skills partition the 41 skills with no overlap', () => {
+        const all = [];
+        for (const entry of catalog.bundles) {
+            const manifest = readJson(path_1.default.join(CONTENT, entry.source, 'bundle.json'));
+            for (const s of manifest.skills)
+                all.push(typeof s === 'string' ? s : s.name);
+        }
+        expect(all.length).toBe(41);
+        expect(new Set(all).size).toBe(41);
+    });
+    it('processes.json has been removed', () => {
+        expect(fs_1.default.existsSync(path_1.default.join(CONTENT, 'processes.json'))).toBe(false);
+    });
+});

package/dist/tests/registry/design-skills.test.js

@@ -0,0 +1,146 @@
+"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 REGISTRY = path_1.default.join(__dirname, '..', '..', '..', 'registry');
+const SKILLS = path_1.default.join(REGISTRY, 'skills');
+const LOCK_FILE = path_1.default.join(__dirname, '..', '..', '..', 'skills-lock.json');
+function frontmatter(skill) {
+    const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, skill, 'SKILL.md'), 'utf-8');
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    expect(match).not.toBeNull();
+    return match[1];
+}
+describe('frontend-craft skill', () => {
+    it('exists with valid frontmatter', () => {
+        const fm = frontmatter('frontend-craft');
+        expect(fm).toMatch(/^name:\s*frontend-craft\s*$/m);
+        expect(fm).toMatch(/^description:\s*.+$/m);
+    });
+    it('bundles emil and taste as internal references', () => {
+        const ref = path_1.default.join(SKILLS, 'frontend-craft', 'reference');
+        expect(fs_1.default.existsSync(path_1.default.join(ref, 'emil-design-eng.md'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(ref, 'design-taste-frontend.md'))).toBe(true);
+    });
+    it('SKILL.md points to its reference files', () => {
+        const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, 'frontend-craft', 'SKILL.md'), 'utf-8');
+        expect(content).toMatch(/reference\/emil-design-eng\.md/);
+        expect(content).toMatch(/reference\/design-taste-frontend\.md/);
+    });
+});
+describe('impeccable skill (non-live scope)', () => {
+    const base = path_1.default.join(SKILLS, 'impeccable');
+    it('exists with valid frontmatter', () => {
+        expect(fs_1.default.existsSync(path_1.default.join(base, 'SKILL.md'))).toBe(true);
+    });
+    it('has no literal .agents/skills/impeccable paths in markdown', () => {
+        const mdFiles = [
+            path_1.default.join(base, 'SKILL.md'),
+            ...fs_1.default.readdirSync(path_1.default.join(base, 'reference')).map((f) => path_1.default.join(base, 'reference', f)),
+        ];
+        for (const f of mdFiles) {
+            const content = fs_1.default.readFileSync(f, 'utf-8');
+            expect(content).not.toMatch(/\.agents\/skills\/impeccable/);
+        }
+    });
+    it('dropped the live/Codex layer', () => {
+        expect(fs_1.default.existsSync(path_1.default.join(base, 'agents'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(base, 'reference', 'live.md'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(base, 'reference', 'codex.md'))).toBe(false);
+        const liveScripts = fs_1.default.readdirSync(path_1.default.join(base, 'scripts')).filter((f) => /^live-/.test(f) || f === 'modern-screenshot.umd.js');
+        expect(liveScripts).toEqual([]);
+    });
+    it('kept the static detector and non-live support scripts', () => {
+        const scripts = path_1.default.join(base, 'scripts');
+        for (const keep of ['detect.mjs', 'context.mjs', 'critique-storage.mjs', 'impeccable-paths.mjs']) {
+            expect(fs_1.default.existsSync(path_1.default.join(scripts, keep))).toBe(true);
+        }
+        expect(fs_1.default.existsSync(path_1.default.join(scripts, 'detector'))).toBe(true);
+    });
+    it('removed the live row from the commands table', () => {
+        const content = fs_1.default.readFileSync(path_1.default.join(base, 'SKILL.md'), 'utf-8');
+        expect(content).not.toMatch(/\|\s*`live`\s*\|/);
+    });
+});
+describe('google stitch skills', () => {
+    for (const s of ['extract-design-md', 'code-to-design', 'react-components']) {
+        it(`${s} exists with SKILL.md`, () => {
+            expect(fs_1.default.existsSync(path_1.default.join(SKILLS, s, 'SKILL.md'))).toBe(true);
+        });
+    }
+});
+describe('catalog/bundles (replaces processes.json)', () => {
+    const catalog = JSON.parse(fs_1.default.readFileSync(path_1.default.join(REGISTRY, 'catalog.json'), 'utf-8'));
+    function readBundle(source) {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(REGISTRY, source, 'bundle.json'), 'utf-8'));
+    }
+    function skillNames(bundle) {
+        return bundle.skills.map((s) => (typeof s === 'string' ? s : s.name));
+    }
+    it('frontend bundle includes the heavy design skills', () => {
+        const entry = catalog.bundles.find((b) => b.name === 'frontend');
+        expect(entry).toBeDefined();
+        const bundle = readBundle(entry.source);
+        const names = skillNames(bundle);
+        for (const s of ['impeccable', 'ui-design', 'extract-design-md', 'code-to-design', 'react-components']) {
+            expect(names).toContain(s);
+        }
+    });
+    it('frontend bundle includes frontend-craft', () => {
+        const entry = catalog.bundles.find((b) => b.name === 'frontend');
+        expect(entry).toBeDefined();
+        const bundle = readBundle(entry.source);
+        expect(skillNames(bundle)).toContain('frontend-craft');
+    });
+    it('every skill referenced by any bundle exists on disk', () => {
+        for (const entry of catalog.bundles) {
+            const bundle = readBundle(entry.source);
+            for (const s of skillNames(bundle)) {
+                expect(fs_1.default.existsSync(path_1.default.join(SKILLS, s, 'SKILL.md'))).toBe(true);
+            }
+        }
+    });
+});
+describe('skills-lock.json', () => {
+    const lock = JSON.parse(fs_1.default.readFileSync(LOCK_FILE, 'utf-8'));
+    it('records provenance for the new external skills', () => {
+        for (const s of ['emil-design-eng', 'design-taste-frontend', 'impeccable', 'extract-design-md', 'code-to-design', 'react-components']) {
+            expect(lock.skills[s]).toBeDefined();
+            expect(lock.skills[s].source).toMatch(/.+\/.+/);
+            expect(lock.skills[s].sourceType).toBe('github');
+        }
+    });
+});
+describe('post-implementation-qa skill', () => {
+    const base = path_1.default.join(SKILLS, 'post-implementation-qa');
+    it('exists with valid frontmatter', () => {
+        const content = fs_1.default.readFileSync(path_1.default.join(base, 'SKILL.md'), 'utf-8');
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        expect(match).not.toBeNull();
+        const fm = match[1];
+        expect(fm).toMatch(/^name:\s*post-implementation-qa\s*$/m);
+        expect(fm).toMatch(/^description:\s*.+$/m);
+    });
+    it('includes deep-review-prompt.md', () => {
+        expect(fs_1.default.existsSync(path_1.default.join(base, 'deep-review-prompt.md'))).toBe(true);
+    });
+    it('SKILL.md contains the awm-qa-complete marker instruction', () => {
+        const content = fs_1.default.readFileSync(path_1.default.join(base, 'SKILL.md'), 'utf-8');
+        expect(content).toMatch(/awm-qa-complete/);
+    });
+});
+describe('development-process QA integration', () => {
+    it('SKILL.md references post-implementation-qa at least 6 times', () => {
+        const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, 'development-process', 'SKILL.md'), 'utf-8');
+        const matches = content.match(/post-implementation-qa/g) || [];
+        expect(matches.length).toBeGreaterThanOrEqual(6);
+    });
+    it('SKILL.md references awm-qa-complete at least 2 times', () => {
+        const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, 'development-process', 'SKILL.md'), 'utf-8');
+        const matches = content.match(/awm-qa-complete/g) || [];
+        expect(matches.length).toBeGreaterThanOrEqual(2);
+    });
+});

package/dist/tests/registry/prose-agnostic.test.js

@@ -0,0 +1,18 @@
+"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 REPO_ROOT = path_1.default.resolve(__dirname, '../../..');
+describe('skill prose stays agent-agnostic (#5)', () => {
+    const files = ['writing-skills/SKILL.md', 'project-constitution/SKILL.md'];
+    for (const f of files) {
+        it(`${f} does not push the model to the ~/.claude/skills path`, () => {
+            const txt = fs_1.default.readFileSync(path_1.default.join(REPO_ROOT, 'registry/skills', f), 'utf-8');
+            expect(txt).not.toMatch(/~\/\.claude\/skills/);
+            expect(txt).not.toMatch(/\.claude\/settings\.json/);
+        });
+    }
+});

package/dist/tests/registry/sensor-packs.test.js

@@ -0,0 +1,45 @@
+"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 REGISTRY_ROOT = path_1.default.join(__dirname, '..', '..', '..', 'registry');
+const PACKS_DIR = path_1.default.join(REGISTRY_ROOT, 'sensor-packs');
+describe('sensor-packs registry', () => {
+    it('sensor-packs directory exists in registry', () => {
+        expect(fs_1.default.existsSync(PACKS_DIR)).toBe(true);
+    });
+    for (const packName of ['js-ts', 'generic']) {
+        describe(`pack: ${packName}`, () => {
+            const packDir = path_1.default.join(PACKS_DIR, packName);
+            it('directory exists', () => {
+                expect(fs_1.default.existsSync(packDir)).toBe(true);
+            });
+            it('has valid pack.json', () => {
+                const packJson = path_1.default.join(packDir, 'pack.json');
+                expect(fs_1.default.existsSync(packJson)).toBe(true);
+                const parsed = JSON.parse(fs_1.default.readFileSync(packJson, 'utf-8'));
+                expect(parsed.name).toBe(packName);
+                expect(typeof parsed.description).toBe('string');
+                expect(typeof parsed.sensors).toBe('object');
+            });
+            it('pack.json name matches directory name', () => {
+                const parsed = JSON.parse(fs_1.default.readFileSync(path_1.default.join(packDir, 'pack.json'), 'utf-8'));
+                expect(parsed.name).toBe(packName);
+            });
+        });
+    }
+    it('js-ts pack has required sensor config files', () => {
+        const jstsDir = path_1.default.join(PACKS_DIR, 'js-ts');
+        expect(fs_1.default.existsSync(path_1.default.join(jstsDir, 'tsconfig.awm.json'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(jstsDir, 'eslint.config.awm.mjs'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(jstsDir, '.semgrep.awm.yml'))).toBe(true);
+    });
+    it('tsconfig.awm.json extends ./tsconfig.json', () => {
+        const tsconfig = JSON.parse(fs_1.default.readFileSync(path_1.default.join(PACKS_DIR, 'js-ts', 'tsconfig.awm.json'), 'utf-8'));
+        expect(tsconfig.extends).toBe('./tsconfig.json');
+        expect(tsconfig.compilerOptions?.strict).toBe(true);
+    });
+});

package/dist/tests/registry/skill-versions.test.js

@@ -0,0 +1,26 @@
+"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 SKILLS_DIR = path_1.default.join(__dirname, '../../../registry/skills');
+function frontmatter(file) {
+    const raw = fs_1.default.readFileSync(file, 'utf-8');
+    const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    return m ? m[1] : '';
+}
+describe('skill frontmatter version', () => {
+    const dirs = fs_1.default.readdirSync(SKILLS_DIR, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .filter((e) => fs_1.default.existsSync(path_1.default.join(SKILLS_DIR, e.name, 'SKILL.md')))
+        .map((e) => e.name);
+    it('finds the 41 skills', () => {
+        expect(dirs.length).toBe(41);
+    });
+    it.each(dirs)('skill "%s" declares a semver version', (name) => {
+        const fm = frontmatter(path_1.default.join(SKILLS_DIR, name, 'SKILL.md'));
+        expect(fm).toMatch(/^version:\s*["']?\d+\.\d+\.\d+["']?\s*$/m);
+    });
+});

package/dist/tests/registry/using-awm.test.js

@@ -0,0 +1,39 @@
+"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"));
+describe('using-awm skill', () => {
+    const skillPath = path_1.default.join(__dirname, '../../../registry/skills/using-awm/SKILL.md');
+    it('exists at the expected path', () => {
+        expect(fs_1.default.existsSync(skillPath)).toBe(true);
+    });
+    it('has a valid frontmatter with required fields', () => {
+        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        expect(match).not.toBeNull();
+        const frontmatter = match[1];
+        expect(frontmatter).toMatch(/^name:\s*using-awm\s*$/m);
+        expect(frontmatter).toMatch(/^description:\s*.+$/m);
+    });
+    it('does NOT contain a model: field (aligned with canon)', () => {
+        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
+        expect(content).not.toMatch(/^model:\s*/m);
+    });
+    it('uses tiered triggering (no blanket 1% mandate)', () => {
+        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
+        expect(content).not.toMatch(/1%/);
+        expect(content).toMatch(/always|siempre/i);
+        expect(content).toMatch(/signal|señal/i);
+    });
+    it('contains SUBAGENT-STOP block (prevents recursion)', () => {
+        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
+        expect(content).toMatch(/<SUBAGENT-STOP>/);
+    });
+    it('points to development-process as default orchestrator', () => {
+        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
+        expect(content).toMatch(/development-process/);
+    });
+});

package/dist/tests/utils/config.test.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/utils/config.test.ts
+const config_1 = require("../../src/utils/config");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('Preferences Manager', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-prefs-'));
+        process.env.AWM_HOME = tmpDir;
+    });
+    afterEach(() => {
+        delete process.env.AWM_HOME;
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('creates default preferences if none exist', () => {
+        const prefs = (0, config_1.getPreferences)();
+        expect(prefs.defaultAgent).toBe('antigravity');
+    });
+    it('saves and loads preferences correctly', () => {
+        (0, config_1.savePreferences)({ defaultAgent: 'opencode', installMethod: 'copy', defaultScope: 'local' });
+        const prefs = (0, config_1.getPreferences)();
+        expect(prefs.defaultAgent).toBe('opencode');
+        expect(prefs.installMethod).toBe('copy');
+    });
+});