agentic-workflow-manager 3.0.1 → 3.2.0

package/dist/tests/core/export/engine.test.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const export_1 = require("../../../src/core/export");
+const okZip = (cwd, zipName) => {
+    fs_1.default.writeFileSync(path_1.default.join(cwd, zipName), 'fake-zip');
+    return { ok: true, missing: false };
+};
+/** Mismo fixture que resolve.test.ts (root falso con bundle dev + 3 skills). */
+function makeRoot() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-engine-root-'));
+    fs_1.default.mkdirSync(path_1.default.join(root, 'bundles/dev'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [{ name: 'dev', source: './bundles/dev', version: '1.0.0', scope: 'baseline' }],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'bundles/dev/bundle.json'), JSON.stringify({
+        name: 'dev', version: '1.0.0', scope: 'baseline', dependsOn: [],
+        skills: ['proc-skill', { name: 'mermaid', onSignal: true }, { name: 'ported', onSignal: true }],
+        workflows: [], agents: [],
+    }));
+    const mk = (name, fm) => {
+        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'), `---\n${fm.join('\n')}\n---\nBody of ${name}.\n`);
+        return dir;
+    };
+    mk('proc-skill', ['name: proc-skill', 'description: "Process skill."']);
+    const mermaid = mk('mermaid', ['name: mermaid', 'version: "1.0.0"', 'portable: true', 'description: "Diagrams."']);
+    fs_1.default.mkdirSync(path_1.default.join(mermaid, 'references'));
+    fs_1.default.writeFileSync(path_1.default.join(mermaid, 'references/flow.md'), 'flow reference bytes');
+    const ported = mk('ported', ['name: ported', 'portable: true', 'description: "Ported."']);
+    fs_1.default.writeFileSync(path_1.default.join(ported, 'port.claude-ai.md'), '---\nname: ported\ndescription: "Custom port."\n---\nOverride body, verbatim.\n');
+    return root;
+}
+describe('runExport (engine end-to-end)', () => {
+    let root;
+    let out;
+    beforeEach(() => {
+        root = makeRoot();
+        out = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-engine-out-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+        fs_1.default.rmSync(out, { recursive: true, force: true });
+    });
+    it('exports a bundle: transform for mermaid, verbatim override for ported, skips proc-skill', () => {
+        const summary = (0, export_1.runExport)({ name: 'dev', out, roots: [root], zip: okZip });
+        expect(summary.kind).toBe('bundle');
+        expect(summary.exported.map((e) => e.name).sort()).toEqual(['mermaid', 'ported']);
+        expect(summary.skipped).toEqual(['proc-skill']);
+        const mermaidMd = fs_1.default.readFileSync(path_1.default.join(out, 'claude-ai/mermaid/SKILL.md'), 'utf-8');
+        expect(mermaidMd).not.toMatch(/^version:/m);
+        expect(mermaidMd).not.toMatch(/^portable:/m);
+        expect(mermaidMd).toContain('defer to the registry');
+        expect(fs_1.default.readFileSync(path_1.default.join(out, 'claude-ai/mermaid/references/flow.md'), 'utf-8')).toBe('flow reference bytes');
+        const portedMd = fs_1.default.readFileSync(path_1.default.join(out, 'claude-ai/ported/SKILL.md'), 'utf-8');
+        expect(portedMd).toBe('---\nname: ported\ndescription: "Custom port."\n---\nOverride body, verbatim.\n'); // cero transforms
+    });
+    it('rejects an unknown target listing the valid ones', () => {
+        expect(() => (0, export_1.runExport)({ name: 'dev', target: 'hermes', out, roots: [root], zip: okZip }))
+            .toThrow(new RegExp(export_1.EXPORT_TARGETS.join('|')));
+    });
+    it('wraps transform errors with the offending file path', () => {
+        // portable: true se mantiene (si no, resolve.ts corta antes por R2.x y nunca llega
+        // a transform.ts); lo que rompe es la ausencia de "description:", que transform.ts exige.
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/mermaid/SKILL.md'), '---\nname: mermaid\nportable: true\n---\nNo description field.\n');
+        expect(() => (0, export_1.runExport)({ name: 'mermaid', out, roots: [root], zip: okZip }))
+            .toThrow(/mermaid[/\\]SKILL\.md/);
+    });
+    it('reads only the provided roots (never ~/.claude/skills)', () => {
+        // La lectura sale exclusivamente de roots: un root vacío no resuelve nada.
+        // Control negativo real: contentRoots() (el fallback al registry instalado)
+        // no debe invocarse en absoluto cuando opts.roots viene dado explícitamente.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const registries = require('../../../src/core/registries');
+        const spy = jest.spyOn(registries, 'contentRoots');
+        const empty = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-root-'));
+        expect(() => (0, export_1.runExport)({ name: 'mermaid', out, roots: [empty], zip: okZip })).toThrow(/neither a bundle nor a skill/);
+        expect(spy).not.toHaveBeenCalled();
+        spy.mockRestore();
+        fs_1.default.rmSync(empty, { recursive: true, force: true });
+    });
+    it('defaults --out to ./awm-export/<target> under the current working directory', () => {
+        const cwdTmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-engine-cwd-'));
+        const originalCwd = process.cwd();
+        process.chdir(cwdTmp);
+        try {
+            const actualCwd = process.cwd();
+            const summary = (0, export_1.runExport)({ name: 'mermaid', roots: [root], zip: okZip }); // sin `out`
+            expect(summary.outDir).toBe(path_1.default.join(actualCwd, 'awm-export', 'claude-ai'));
+            expect(fs_1.default.existsSync(path_1.default.join(actualCwd, 'awm-export/claude-ai/mermaid/SKILL.md'))).toBe(true);
+        }
+        finally {
+            process.chdir(originalCwd);
+            fs_1.default.rmSync(cwdTmp, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/export/pack.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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const pack_1 = require("../../../src/core/export/pack");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const childProcess = require('child_process');
+const okZip = (cwd, zipName) => {
+    fs_1.default.writeFileSync(path_1.default.join(cwd, zipName), 'fake-zip');
+    return { ok: true, missing: false };
+};
+const missingZip = () => ({ ok: false, missing: true });
+describe('packSkill', () => {
+    let src;
+    let out;
+    beforeEach(() => {
+        src = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pack-src-'));
+        out = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pack-out-'));
+        fs_1.default.writeFileSync(path_1.default.join(src, 'SKILL.md'), 'canonical');
+        fs_1.default.mkdirSync(path_1.default.join(src, 'references'));
+        fs_1.default.writeFileSync(path_1.default.join(src, 'references/a.md'), 'ref-A bytes');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(src, { recursive: true, force: true });
+        fs_1.default.rmSync(out, { recursive: true, force: true });
+    });
+    it('writes adapted SKILL.md and byte-identical references', () => {
+        const r = (0, pack_1.packSkill)({ name: 'x', adaptedSkillMd: 'adapted', srcDir: src, targetRoot: out, zip: okZip });
+        expect(fs_1.default.readFileSync(path_1.default.join(out, 'x/SKILL.md'), 'utf-8')).toBe('adapted');
+        expect(fs_1.default.readFileSync(path_1.default.join(out, 'x/references/a.md'), 'utf-8')).toBe('ref-A bytes');
+        expect(r.zip).toBe(path_1.default.join(out, 'x.zip'));
+    });
+    it('re-export cleans its own subtree first (stale files gone)', () => {
+        fs_1.default.mkdirSync(path_1.default.join(out, 'x'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(out, 'x/stale.md'), 'old');
+        fs_1.default.writeFileSync(path_1.default.join(out, 'x.zip'), 'old-zip');
+        (0, pack_1.packSkill)({ name: 'x', adaptedSkillMd: 'adapted', srcDir: src, targetRoot: out, zip: missingZip });
+        expect(fs_1.default.existsSync(path_1.default.join(out, 'x/stale.md'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(out, 'x.zip'))).toBe(false);
+    });
+    it('falls back to folder-only when zip binary is missing', () => {
+        const r = (0, pack_1.packSkill)({ name: 'x', adaptedSkillMd: 'adapted', srcDir: src, targetRoot: out, zip: missingZip });
+        expect(r.zip).toBeNull();
+        expect(r.zipMissing).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(out, 'x/SKILL.md'))).toBe(true);
+    });
+    it('skill without references/ packs SKILL.md alone', () => {
+        fs_1.default.rmSync(path_1.default.join(src, 'references'), { recursive: true });
+        (0, pack_1.packSkill)({ name: 'x', adaptedSkillMd: 'adapted', srcDir: src, targetRoot: out, zip: okZip });
+        expect(fs_1.default.existsSync(path_1.default.join(out, 'x/references'))).toBe(false);
+    });
+    it('throws when the zip function reports a real failure (not missing binary)', () => {
+        const failingZip = () => ({ ok: false, missing: false });
+        expect(() => (0, pack_1.packSkill)({ name: 'x', adaptedSkillMd: 'adapted', srcDir: src, targetRoot: out, zip: failingZip }))
+            .toThrow(/zip failed/);
+    });
+    it('refuses to export when references/ contains a symlink (blocks zip-dereference exfiltration)', () => {
+        // Simulate the exfiltration shape: a "secret" file living entirely
+        // outside srcDir, symlinked from within references/.
+        const secretsDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pack-secret-'));
+        const secretPath = path_1.default.join(secretsDir, 'id_rsa');
+        const secretContents = 'THIS-IS-A-PRIVATE-KEY-SHOULD-NEVER-LEAK';
+        fs_1.default.writeFileSync(secretPath, secretContents);
+        fs_1.default.symlinkSync(secretPath, path_1.default.join(src, 'references/evil-link'));
+        try {
+            expect(() => (0, pack_1.packSkill)({ name: 'x', adaptedSkillMd: 'adapted', srcDir: src, targetRoot: out, zip: okZip })).toThrow(/symlink/i);
+            // Nothing under targetRoot should ever contain the secret's bytes,
+            // whether as a copied symlink or a dereferenced regular file.
+            const walk = (dir) => {
+                if (!fs_1.default.existsSync(dir))
+                    return [];
+                return fs_1.default.readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
+                    const full = path_1.default.join(dir, e.name);
+                    if (e.isDirectory())
+                        return walk(full);
+                    if (e.isSymbolicLink())
+                        return [full]; // leaked symlink itself is also unacceptable
+                    return [full];
+                });
+            };
+            for (const f of walk(out)) {
+                const st = fs_1.default.lstatSync(f);
+                if (st.isSymbolicLink()) {
+                    throw new Error(`leaked symlink found under targetRoot: ${f}`);
+                }
+                const contents = fs_1.default.readFileSync(f, 'utf-8');
+                expect(contents).not.toContain(secretContents);
+            }
+        }
+        finally {
+            fs_1.default.rmSync(secretsDir, { recursive: true, force: true });
+        }
+    });
+});
+describe('defaultZip (system binary, layered)', () => {
+    it('produces a real zip when the binary exists, or reports missing', () => {
+        const cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-zip-'));
+        fs_1.default.mkdirSync(path_1.default.join(cwd, 'folder'));
+        fs_1.default.writeFileSync(path_1.default.join(cwd, 'folder/f.txt'), 'x');
+        const r = (0, pack_1.defaultZip)(cwd, 'folder.zip', 'folder');
+        if (r.missing) {
+            expect(fs_1.default.existsSync(path_1.default.join(cwd, 'folder.zip'))).toBe(false); // degrade limpio
+        }
+        else {
+            expect(r.ok).toBe(true);
+            expect(fs_1.default.existsSync(path_1.default.join(cwd, 'folder.zip'))).toBe(true);
+        }
+        fs_1.default.rmSync(cwd, { recursive: true, force: true });
+    });
+    it('returns missing:true when spawnSync reports ENOENT (binary absent)', () => {
+        const spy = jest.spyOn(childProcess, 'spawnSync').mockReturnValue({
+            error: Object.assign(new Error('spawn zip ENOENT'), { code: 'ENOENT' }),
+        });
+        const r = (0, pack_1.defaultZip)('/irrelevant', 'folder.zip', 'folder');
+        expect(r).toEqual({ ok: false, missing: true });
+        spy.mockRestore();
+    });
+});

package/dist/tests/core/export/resolve.test.js

@@ -0,0 +1,78 @@
+"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"));
+const resolve_1 = require("../../../src/core/export/resolve");
+/** Content root falso: catalog + bundle dev + 3 skills. */
+function makeRoot() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-export-root-'));
+    fs_1.default.mkdirSync(path_1.default.join(root, 'bundles/dev'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [{ name: 'dev', source: './bundles/dev', version: '1.0.0', scope: 'baseline' }],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'bundles/dev/bundle.json'), JSON.stringify({
+        name: 'dev', version: '1.0.0', scope: 'baseline', dependsOn: [],
+        skills: ['proc-skill', { name: 'mermaid', onSignal: true }, { name: 'ported', onSignal: true }],
+        workflows: [], agents: [],
+    }));
+    const mk = (name, fm) => {
+        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'), `---\n${fm.join('\n')}\n---\nBody.\n`);
+        return dir;
+    };
+    mk('proc-skill', ['name: proc-skill', 'description: "Process skill."']); // NO portable
+    mk('mermaid', ['name: mermaid', 'portable: true', 'description: "Diagrams."']);
+    const ported = mk('ported', ['name: ported', 'portable: true', 'description: "Ported."']);
+    fs_1.default.writeFileSync(path_1.default.join(ported, 'port.claude-ai.md'), '---\nname: ported\ndescription: "Custom."\n---\nCustom body.\n');
+    return root;
+}
+describe('resolveExport', () => {
+    let root;
+    beforeEach(() => { root = makeRoot(); });
+    afterEach(() => { fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    it('resolves a bundle: portable skills in, non-portable listed as skipped', () => {
+        const res = (0, resolve_1.resolveExport)('dev', [root]);
+        expect(res.kind).toBe('bundle');
+        expect(res.skills.map((s) => s.name).sort()).toEqual(['mermaid', 'ported']);
+        expect(res.skipped).toEqual(['proc-skill']);
+    });
+    it('detects the override path when present', () => {
+        const res = (0, resolve_1.resolveExport)('dev', [root]);
+        const ported = res.skills.find((s) => s.name === 'ported');
+        expect(ported.overridePath).toBe(path_1.default.join(root, 'skills/ported/port.claude-ai.md'));
+        const mermaid = res.skills.find((s) => s.name === 'mermaid');
+        expect(mermaid.overridePath).toBeNull();
+    });
+    it('resolves an individual portable skill', () => {
+        const res = (0, resolve_1.resolveExport)('mermaid', [root]);
+        expect(res.kind).toBe('skill');
+        expect(res.skills).toHaveLength(1);
+        expect(res.skipped).toEqual([]);
+    });
+    it('fails on an explicitly requested non-portable skill', () => {
+        expect(() => (0, resolve_1.resolveExport)('proc-skill', [root])).toThrow(/portable/);
+    });
+    it('fails on unknown name, listing available bundles', () => {
+        expect(() => (0, resolve_1.resolveExport)('nope', [root])).toThrow(/dev/);
+    });
+    it('fails when a bundle has zero portable skills', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/mermaid/SKILL.md'), '---\nname: mermaid\ndescription: "D."\n---\nB.\n');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/ported/SKILL.md'), '---\nname: ported\ndescription: "P."\n---\nB.\n');
+        fs_1.default.rmSync(path_1.default.join(root, 'skills/ported/port.claude-ai.md'));
+        expect(() => (0, resolve_1.resolveExport)('dev', [root])).toThrow(/no portable skills/i);
+    });
+    it('fails on override without portable: true (inconsistent metadata)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/ported/SKILL.md'), '---\nname: ported\ndescription: "P."\n---\nB.\n');
+        expect(() => (0, resolve_1.resolveExport)('ported', [root])).toThrow(/inconsistent/i);
+    });
+    it('fails on override without portable: true when resolved via a bundle (assertOverrideConsistency bundle-loop path)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/ported/SKILL.md'), '---\nname: ported\ndescription: "P."\n---\nB.\n');
+        expect(() => (0, resolve_1.resolveExport)('dev', [root])).toThrow(/inconsistent/i);
+    });
+});

package/dist/tests/core/export/transform.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const transform_1 = require("../../../src/core/export/transform");
+const FM = (lines) => `---\n${lines.join('\n')}\n---\nBody line.\n`;
+describe('claudeAiTransform', () => {
+    it('strips version and portable, keeps other keys and body intact', () => {
+        const input = FM(['name: mermaid-diagrams', 'version: "1.0.0"', 'portable: true', 'description: "Guide."']);
+        const out = (0, transform_1.claudeAiTransform)(input, 'mermaid-diagrams');
+        expect(out).not.toMatch(/^version:/m);
+        expect(out).not.toMatch(/^portable:/m);
+        expect(out).toMatch(/^name: mermaid-diagrams$/m);
+        expect(out).toContain('Body line.\n');
+    });
+    it('appends the deference line inside a quoted description', () => {
+        const input = FM(['name: x', 'portable: true', 'description: "Does things."']);
+        const out = (0, transform_1.claudeAiTransform)(input, 'x');
+        expect(out).toContain(`description: "Does things. ${(0, transform_1.DEFERENCE_LINE)('x')}"`);
+    });
+    it('appends the deference line to an unquoted description', () => {
+        const input = FM(['name: x', 'portable: true', 'description: Does things.']);
+        const out = (0, transform_1.claudeAiTransform)(input, 'x');
+        expect(out).toContain(`description: Does things. ${(0, transform_1.DEFERENCE_LINE)('x')}`);
+    });
+    it('appends the deference line inside a single-quoted description', () => {
+        const input = FM(['name: x', 'portable: true', "description: 'Does things.'"]);
+        const out = (0, transform_1.claudeAiTransform)(input, 'x');
+        // DEFERENCE_LINE itself always contains an apostrophe ("registry's"), so
+        // even a fixture with no apostrophe of its own must see it doubled ('')
+        // per YAML single-quote escaping once spliced into a single-quoted scalar.
+        expect(out).toContain(`description: 'Does things. ${(0, transform_1.DEFERENCE_LINE)('x').replace(/'/g, "''")}'`);
+    });
+    it('appends the deference line inside a double-quoted description with trailing whitespace', () => {
+        const input = FM(['name: x', 'portable: true', 'description: "Does things."   ']);
+        const out = (0, transform_1.claudeAiTransform)(input, 'x');
+        expect(out).toContain(`description: "Does things. ${(0, transform_1.DEFERENCE_LINE)('x')}"`);
+    });
+    it('accepts CRLF-terminated frontmatter', () => {
+        const input = '---\r\nname: x\r\nportable: true\r\ndescription: "Does things."\r\n---\r\nBody line.\r\n';
+        const out = (0, transform_1.claudeAiTransform)(input, 'x');
+        expect(out).not.toMatch(/^portable:/m);
+        expect(out).toContain(`description: "Does things. ${(0, transform_1.DEFERENCE_LINE)('x')}"`);
+        expect(out).toContain('Body line.\r\n');
+    });
+    it('throws on missing frontmatter block', () => {
+        expect(() => (0, transform_1.claudeAiTransform)('No frontmatter here.', 'x')).toThrow(/frontmatter/);
+    });
+    it('throws on unterminated frontmatter block', () => {
+        expect(() => (0, transform_1.claudeAiTransform)('---\nname: x\ndescription: "D."\n', 'x')).toThrow(/unterminated/);
+    });
+    it('throws on frontmatter without description', () => {
+        expect(() => (0, transform_1.claudeAiTransform)(FM(['name: x', 'portable: true']), 'x')).toThrow(/description/);
+    });
+    it('throws on multi-line (block scalar) description', () => {
+        expect(() => (0, transform_1.claudeAiTransform)(FM(['name: x', 'description: >', '  folded text']), 'x')).toThrow(/single-line/);
+    });
+    it('escapes an apostrophe in the deference line when appending to a single-quoted description', () => {
+        const input = FM(['name: mermaid', 'portable: true', "description: 'Diagrams and flowcharts.'"]);
+        const out = (0, transform_1.claudeAiTransform)(input, 'mermaid');
+        // The apostrophe in "registry's" must be doubled ('') per YAML single-quote escaping.
+        expect(out).toContain("registry''s mermaid skill");
+        expect(out).not.toContain("registry's mermaid skill");
+        const descLine = out.split('\n').find((l) => l.startsWith('description:'));
+        expect(descLine).toBe(`description: 'Diagrams and flowcharts. ${(0, transform_1.DEFERENCE_LINE)('mermaid').replace(/'/g, "''")}'`);
+        // Sanity check the result is well-formed: single-quoted scalar body has no
+        // lone (unescaped) apostrophes — every ' is either the opening/closing
+        // quote or part of a doubled '' pair.
+        const body = descLine.slice('description: \''.length, -1);
+        expect(body.replace(/''/g, '')).not.toMatch(/'/);
+    });
+    it('throws when a quoted description has trailing content after its closing quote (e.g. inline comment)', () => {
+        const input = FM(['name: x', 'portable: true', 'description: "Does things." # a comment']);
+        expect(() => (0, transform_1.claudeAiTransform)(input, 'x')).toThrow(/trailing content|comment/i);
+    });
+});

package/dist/tests/core/init/mutation-targets.test.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Direct, focused tests for planInitMutationTargets (mutation-targets.ts).
+//
+// Previously this module was only exercised indirectly via
+// tests/commands/init.test.ts's broader init-flow tests, which happen to hit
+// the hooks.settingsPath branch but not the ambient/baseline/project-extension
+// branches, nor the Finding-1 fix (global skills directory) directly.
+//
+// registries.ts computes AWM_HOME at module-require time (not call time), so
+// every test here sets HOME/AWM_HOME BEFORE requiring
+// core/init/mutation-targets.ts, and calls jest.resetModules() first — the
+// same pattern used throughout tests/commands/hooks/install.test.ts and
+// tests/core/skill-integrity.test.ts. Per CLAUDE.md, no test may touch the
+// real ~/.awm.
+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: [],
+    };
+}
+let tmpHome;
+let originalHome;
+let originalAwmHome;
+let extraDirs;
+beforeEach(() => {
+    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-'));
+    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();
+    extraDirs = [];
+});
+afterEach(() => {
+    fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    for (const dir of extraDirs)
+        fs_1.default.rmSync(dir, { 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;
+});
+/**
+ * Loads a fresh copy of the module under test (and providerFor, which needs
+ * the same env-var-driven paths) AFTER env vars are set for this test.
+ */
+function load() {
+    const mutationTargets = require('../../../src/core/init/mutation-targets');
+    const providers = require('../../../src/providers');
+    return {
+        planInitMutationTargets: mutationTargets.planInitMutationTargets,
+        providerFor: providers.providerFor,
+    };
+}
+/** A cwd guaranteed to have no project-root marker (.git/package.json/.awm) in its ancestry. */
+function bareCwd() {
+    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-cwd-'));
+    extraDirs.push(dir);
+    return dir;
+}
+describe('planInitMutationTargets', () => {
+    it('always includes preferences.json and the artifact-state file', () => {
+        const { planInitMutationTargets } = load();
+        const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles: [] });
+        expect(targets).toContain(path_1.default.join(tmpHome, '.awm', 'preferences.json'));
+        expect(targets).toContain(path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json'));
+    });
+    describe('hooks', () => {
+        it('includes hooks.settingsPath and hooks.scriptsDir for an agent with a hook config (claude-code)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('claude-code');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles: [] });
+            expect(provider.hooks).toBeDefined();
+            expect(targets).toContain(provider.hooks.settingsPath);
+            expect(targets).toContain(provider.hooks.scriptsDir);
+        });
+        it('includes hooks.json + scriptsDir for codex (its own hook config shape)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('codex');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'codex', bundles: [] });
+            expect(targets).toContain(provider.hooks.settingsPath);
+            expect(targets).toContain(provider.hooks.scriptsDir);
+        });
+        it('includes no hook paths for an agent with no hook config (antigravity)', () => {
+            const { planInitMutationTargets } = load();
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'antigravity', bundles: [] });
+            // antigravity has neither hooks nor injection — its only entries are
+            // the two always-present machine paths.
+            expect(targets).toEqual([
+                path_1.default.join(tmpHome, '.awm', 'preferences.json'),
+                path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json'),
+                path_1.default.join(tmpHome, '.gemini', 'antigravity', 'skills'),
+            ]);
+        });
+    });
+    describe('injection', () => {
+        it('includes the config-instructions path for opencode', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('opencode');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'opencode', bundles: [] });
+            expect(provider.injection?.type).toBe('config-instructions');
+            expect(targets).toContain(provider.injection.configPath);
+        });
+        it('includes the managed-agents-md global path for codex', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('codex');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'codex', bundles: [] });
+            expect(provider.injection?.type).toBe('managed-agents-md');
+            expect(targets).toContain(provider.injection.globalPath);
+        });
+        it('adds no separate injection path for claude-code (cc-settings-merge is covered by the hook)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('claude-code');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles: [] });
+            expect(provider.injection?.type).toBe('cc-settings-merge');
+            // Every target should be explainable by preferences/state/hooks/skills-dir —
+            // none of them should be a bespoke injection config file.
+            expect(targets).toEqual([
+                path_1.default.join(tmpHome, '.awm', 'preferences.json'),
+                path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json'),
+                provider.hooks.settingsPath,
+                provider.hooks.scriptsDir,
+                provider.skill.global,
+            ]);
+        });
+    });
+    describe('machine-level bundle targets (baseline + ambient)', () => {
+        it('includes physical skill targets for baseline and ambient bundles, but not a project-scope bundle', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const bundles = [
+                bundle('dev-core', 'baseline', ['using-awm']),
+                bundle('ambient-pack', 'ambient', ['ambient-skill']),
+                bundle('project-only', 'project', ['project-skill']),
+            ];
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
+            const skillsDir = providerFor('claude-code').skill.global;
+            expect(targets).toContain(path_1.default.join(skillsDir, 'using-awm'));
+            expect(targets).toContain(path_1.default.join(skillsDir, 'ambient-skill'));
+            // project-scope bundles are only enumerated via .awm/profile.json
+            // extensions below, never from the machine-level baseline/ambient pass.
+            expect(targets).not.toContain(path_1.default.join(skillsDir, 'project-skill'));
+        });
+    });
+    describe('project-level targets', () => {
+        function makeProjectRoot() {
+            const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-project-'));
+            fs_1.default.mkdirSync(path_1.default.join(root, '.git')); // project-root marker for findProjectRoot
+            extraDirs.push(root);
+            return root;
+        }
+        it('includes profile.json, sensors.json, and extension bundle targets when a project root is found', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['frontend'] }));
+            const bundles = [bundle('frontend', 'project', ['frontend-skill'])];
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'claude-code', bundles });
+            expect(targets).toContain(path_1.default.join(projectRoot, '.awm', 'profile.json'));
+            expect(targets).toContain(path_1.default.join(projectRoot, '.awm', 'sensors.json'));
+            // frontend is a project-scope bundle -> installs locally under the project root
+            const localSkillsDir = path_1.default.join(projectRoot, providerFor('claude-code').skill.local);
+            expect(targets).toContain(path_1.default.join(localSkillsDir, 'frontend-skill'));
+        });
+        it('includes the project injection file for config-instructions agents (opencode)', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'opencode', bundles: [] });
+            expect(targets).toContain(path_1.default.join(projectRoot, 'opencode.json'));
+        });
+        it('includes the project injection file (AGENTS.md) for managed-agents-md agents (codex)', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'codex', bundles: [] });
+            expect(targets).toContain(path_1.default.join(projectRoot, 'AGENTS.md'));
+        });
+        it('omits every project-level target when no project root is found', () => {
+            const { planInitMutationTargets } = load();
+            const cwd = bareCwd(); // no .git/package.json/.awm ancestor
+            const targets = planInitMutationTargets({ cwd, agent: 'claude-code', bundles: [] });
+            expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'profile.json')))).toBe(false);
+            expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'sensors.json')))).toBe(false);
+        });
+        it('ignores an extension named in the profile that no longer resolves to a known bundle', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['stale-bundle'] }));
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'claude-code', bundles: [] });
+            const localSkillsDir = path_1.default.join(projectRoot, providerFor('claude-code').skill.local);
+            // No target should be produced under the local skills dir for a bundle
+            // that isn't in the (empty) known-bundles list passed in.
+            expect(targets.some((t) => t.startsWith(localSkillsDir))).toBe(false);
+        });
+    });
+    describe('Finding 1 fix — global skills directory itself', () => {
+        it('includes providerFor(agent).skill.global for every agent, independent of the bundle catalog', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            for (const agent of ['claude-code', 'codex', 'opencode', 'antigravity']) {
+                const targets = planInitMutationTargets({ cwd: bareCwd(), agent, bundles: [] });
+                expect(targets).toContain(providerFor(agent).skill.global);
+            }
+        });
+        it('the skills-directory target covers orphaned entries repairGlobalSkills would mutate, not just bundle-derived subpaths', () => {
+            // Regression guard for the logic gap: before the fix, only
+            // bundle-DERIVED skill paths (e.g. .../skills/using-awm) were
+            // enumerated. An orphaned symlink like .../skills/some-old-skill
+            // (belonging to no currently-known bundle — the exact condition
+            // that makes repairGlobalSkills classify it as repairable/dead)
+            // would never appear in the bundle-driven enumeration. The parent
+            // directory itself must be present so beginBackupSession snapshots
+            // the whole tree.
+            const { planInitMutationTargets, providerFor } = load();
+            const bundles = [bundle('dev-core', 'baseline', ['using-awm'])];
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
+            const skillsDir = providerFor('claude-code').skill.global;
+            expect(targets).toContain(skillsDir);
+            // Sanity: the orphan path itself is a child of the now-covered dir,
+            // even though it is never separately enumerated.
+            const orphanPath = path_1.default.join(skillsDir, 'some-old-orphaned-skill');
+            expect(orphanPath.startsWith(skillsDir)).toBe(true);
+        });
+    });
+});

package/dist/tests/core/init/orchestrator.test.js

@@ -74,7 +74,7 @@ describe('runInitSteps — orchestrator', () => {
         const contentDir = roots[0] ?? '';
         const ctx = gatherContext({ cwd, bundles });
         return {
-            cwd, ctx, bundles, agent: 'claude-code', installMethod: 'symlink',
+            cwd, ctx, bundles, agent: 'claude-code', enabledAgents: ['claude-code'], installMethod: 'symlink',
             registryRoot: contentRoot, contentDir, sensorPacksRoot: contentRoot,
             confirmExtensions: async (p) => p,
             // syncCache es no-op: el cache ya está sembrado en disco