agentic-workflow-manager 3.13.4 → 3.13.6

package/dist/tests/core/project-skill-links.test.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Project-scope skill symlinks had no maintenance path at all.
+//
+// The machinery exists and is exercised every `awm init` / `awm registry sync`:
+// `classifySkillLinks` finds dangling symlinks, `repairSkillLinks` re-links the ones
+// the registry can still serve and prunes the ones it cannot. But every entry point
+// pointed it at `provider.skill.global` only. A dangling link under a PROJECT's
+// `.claude/skills/` (registry re-cloned, skill renamed upstream, bundle removed from
+// `.awm/profile.json`) was:
+//
+//   - never healed — `awm sync` installs what the profile declares and looks at
+//     nothing else, so a link whose bundle was dropped is simply left behind;
+//   - never pruned — it stays in the tree indefinitely, and the agent trips on it
+//     when it tries to read the skill's SKILL.md;
+//   - never reported — `awm doctor`'s `globalSkills` reads the global dir, so nothing
+//     on any surface mentions it.
+//
+// For Copilot the gap is total, not partial: `skill.global` is null, so *every* skill
+// it has is project-scope, and none of them had any integrity path whatsoever.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const skill_integrity_1 = require("../../src/core/skill-integrity");
+const providers_1 = require("../../src/providers");
+describe('project-scope skill links get the same integrity path as global ones', () => {
+    let registry;
+    let projectRoot;
+    const made = [];
+    beforeEach(() => {
+        registry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-projlink-reg-'));
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-projlink-proj-'));
+        made.push(registry, projectRoot);
+        fs_1.default.mkdirSync(path_1.default.join(registry, 'skills', 'alive'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'skills', 'alive', 'SKILL.md'), '# alive\n');
+    });
+    afterAll(() => { for (const d of made)
+        fs_1.default.rmSync(d, { recursive: true, force: true }); });
+    /** The dir where `agent`'s project-scope skills live, with the links pre-created. */
+    function localSkillsDir(agent, links) {
+        const dir = path_1.default.join(projectRoot, (0, providers_1.providerFor)(agent).skill.local);
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        for (const [name, target] of Object.entries(links))
+            fs_1.default.symlinkSync(target, path_1.default.join(dir, name));
+        return dir;
+    }
+    it('classifies a dangling project link as repairable when the registry still has it', () => {
+        const dir = localSkillsDir('claude-code', { alive: path_1.default.join(registry, 'gone', 'alive') });
+        const out = (0, skill_integrity_1.classifySkillLinks)(dir, [registry]);
+        expect(out.repairable).toEqual(['alive']);
+        expect(out.dead).toEqual([]);
+    });
+    it('classifies a dangling project link as dead when the registry no longer has it', () => {
+        const dir = localSkillsDir('claude-code', { removed: path_1.default.join(registry, 'skills', 'removed') });
+        const out = (0, skill_integrity_1.classifySkillLinks)(dir, [registry]);
+        expect(out.dead).toEqual(['removed']);
+        expect(out.repairable).toEqual([]);
+    });
+    it('awm sync heals a project link the registry can still serve', () => {
+        const dir = localSkillsDir('claude-code', { alive: path_1.default.join(registry, 'moved', 'alive') });
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code'], [registry]);
+        expect(results.find(r => r.agent === 'claude-code').result.relinked).toEqual(['alive']);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'alive', 'SKILL.md'))).toBe(true);
+    });
+    it('prunes a project link nothing can serve any more', () => {
+        const dir = localSkillsDir('claude-code', { removed: path_1.default.join(registry, 'skills', 'removed') });
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code'], [registry]);
+        expect(results.find(r => r.agent === 'claude-code').result.pruned).toEqual(['removed']);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'removed'))).toBe(false);
+        expect(fs_1.default.lstatSync(dir).isDirectory()).toBe(true);
+    });
+    it('covers Copilot, whose skills are ONLY ever project-scope', () => {
+        expect((0, providers_1.providerFor)('copilot').skill.global).toBeNull(); // premise of this test
+        const dir = localSkillsDir('copilot', { alive: path_1.default.join(registry, 'moved', 'alive') });
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['copilot'], [registry]);
+        expect(results.find(r => r.agent === 'copilot').result.relinked).toEqual(['alive']);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'alive', 'SKILL.md'))).toBe(true);
+    });
+    it('leaves the user\'s own files alone — only dangling symlinks are touched', () => {
+        const dir = localSkillsDir('claude-code', { alive: path_1.default.join(registry, 'skills', 'alive') });
+        fs_1.default.mkdirSync(path_1.default.join(dir, 'hand-written'));
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'hand-written', 'SKILL.md'), '# mine\n');
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code'], [registry]);
+        const r = results.find(x => x.agent === 'claude-code').result;
+        expect(r.relinked).toEqual([]);
+        expect(r.pruned).toEqual([]);
+        expect(fs_1.default.readFileSync(path_1.default.join(dir, 'hand-written', 'SKILL.md'), 'utf-8')).toBe('# mine\n');
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'alive'))).toBe(true);
+    });
+    it('skips agents whose project skills dir does not exist', () => {
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code', 'copilot'], [registry]);
+        expect(results).toEqual([]);
+    });
+});
+// Wiring, not just capability: I15's actual defect was that the healing primitive
+// already existed and nothing called it for project scope. A green unit test of the
+// primitive would have looked identical before and after. So assert the call.
+describe('awm sync reaches the project-scope reconciliation', () => {
+    let projectRoot;
+    let home;
+    let saved;
+    beforeEach(() => {
+        jest.resetModules();
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-syncwire-home-'));
+        saved = { HOME: process.env.HOME, AWM_HOME: process.env.AWM_HOME };
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+        fs_1.default.mkdirSync(path_1.default.join(home, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(home, '.awm', 'preferences.json'), JSON.stringify({
+            enabledAgents: ['claude-code'], defaultAgent: 'claude-code',
+            installMethod: 'symlink', defaultScope: 'global',
+        }));
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-syncwire-proj-'));
+        fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+    });
+    afterEach(() => {
+        if (saved.HOME === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = saved.HOME;
+        if (saved.AWM_HOME === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = saved.AWM_HOME;
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    const writeProfile = (extensions) => fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions }));
+    async function sync(spy) {
+        const { runSyncCore } = require('../../src/commands/sync');
+        return runSyncCore({ cwd: projectRoot }, {
+            syncRegistries: async () => [],
+            verifyMinCliVersions: () => [],
+            verifyProjectPins: async () => [],
+            syncProfile: () => ({ installed: [], skipped: [], extensions: [], transactionIds: [], modifiedFiles: [] }),
+            reconcileProjectSkillLinks: spy,
+        });
+    }
+    it('reconciles project links on a normal sync', async () => {
+        writeProfile(['demo']);
+        const spy = jest.fn((_root, _agents, _roots) => []);
+        await sync(spy);
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy.mock.calls[0][0]).toBe(projectRoot);
+        expect(spy.mock.calls[0][1]).toEqual(['claude-code']);
+    });
+    it('reconciles project links even when the profile has no extensions left', async () => {
+        // The case that produces orphans in the first place: the extension that owned
+        // them was removed. That path used to return early, touching nothing.
+        writeProfile([]);
+        const spy = jest.fn((_root, _agents, _roots) => []);
+        const out = await sync(spy);
+        expect(out.code).toBe(0);
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/tests/core/provider-artifacts.test.js

@@ -42,24 +42,76 @@ describe('scanLegacyArtifacts', () => {
             process.env.AWM_HOME = originalAwmHome;
         fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
     });
-    it('never lists Codex TOML agents for legacy removal', () => {
+    /** Registra artefactos como propiedad de AWM, que es lo que ahora habilita
+     *  que `awm remove` los ofrezca. */
+    function own(records) {
+        const file = path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        fs_1.default.writeFileSync(file, JSON.stringify(records.map((r) => ({
+            ...r, scope: 'global', sourcePath: '/tmp/src', owners: ['codex'],
+        }))));
+    }
+    it('lista los artefactos renderizados que AWM instalo, incluidos los .toml de codex', () => {
+        // Este test asertaba lo contrario: que los agents TOML de codex NUNCA
+        // se listaran. Eso codificaba el bug — `scanLegacyArtifacts` se tragaba
+        // `UnsupportedRendererError`, asi que `awm remove` era un no-op
+        // permanente para los skills de cursor/copilot y los agents de codex
+        // ("no hay artefactos instalados", con el directorio lleno).
+        // Un artefacto que AWM instalo tiene que poder desinstalarse.
         const skillPath = path_1.default.join(tmpHome, '.agents/skills/linked-skill');
-        const agentPath = path_1.default.join(tmpHome, '.codex/agents/protected.toml');
+        const agentPath = path_1.default.join(tmpHome, '.codex/agents/rendered.toml');
         fs_1.default.mkdirSync(skillPath, { recursive: true });
         fs_1.default.mkdirSync(path_1.default.dirname(agentPath), { recursive: true });
-        fs_1.default.writeFileSync(agentPath, 'name = "protected"\n');
+        fs_1.default.writeFileSync(agentPath, 'name = "rendered"\n');
+        own([
+            { name: 'linked-skill', type: 'skill', targetPath: skillPath, renderer: 'link' },
+            { name: 'rendered.toml', type: 'agent', targetPath: agentPath, renderer: 'codex-agent-toml' },
+        ]);
         const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['codex'], 'global');
-        const legacyRemove = jest.fn((target) => fs_1.default.rmSync(target, {
-            recursive: true,
-            force: true,
-        }));
-        for (const artifact of listed) {
-            for (const fullPath of artifact.fullPaths)
-                legacyRemove(fullPath);
-        }
-        expect(listed.map((artifact) => artifact.name)).toEqual(['linked-skill']);
-        expect(legacyRemove).not.toHaveBeenCalledWith(agentPath);
-        expect(fs_1.default.existsSync(agentPath)).toBe(true);
+        expect(listed.map((a) => a.name).sort()).toEqual(['linked-skill', 'rendered.toml']);
+    });
+    it('NO lista archivos que AWM no instalo — el directorio no es suyo para ofrecerlo', () => {
+        // Antes listaba el directorio entero, asi que un skill escrito a mano
+        // por el usuario aparecia en el menu de borrado.
+        const mine = path_1.default.join(tmpHome, '.agents/skills/awm-skill');
+        const theirs = path_1.default.join(tmpHome, '.agents/skills/mi-skill-personal');
+        fs_1.default.mkdirSync(mine, { recursive: true });
+        fs_1.default.mkdirSync(theirs, { recursive: true });
+        own([{ name: 'awm-skill', type: 'skill', targetPath: mine, renderer: 'link' }]);
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['codex'], 'global');
+        expect(listed.map((a) => a.name)).toEqual(['awm-skill']);
+        expect(listed.flatMap((a) => a.fullPaths)).not.toContain(theirs);
+    });
+    it('no colapsa dos tipos distintos que comparten nombre (borraria el equivocado)', () => {
+        // Antes la clave era solo el nombre, a traves de todos los tipos: un
+        // workflow `deploy.md` y un agent `deploy.md` colapsaban en UNA entrada,
+        // asi que elegir "deploy.md" borraba ambos.
+        const wf = path_1.default.join(tmpHome, '.gemini/antigravity/global_workflows/deploy.md');
+        const ag = path_1.default.join(tmpHome, '.claude/agents/deploy.md');
+        fs_1.default.mkdirSync(path_1.default.dirname(wf), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.dirname(ag), { recursive: true });
+        fs_1.default.writeFileSync(wf, 'wf');
+        fs_1.default.writeFileSync(ag, 'ag');
+        own([
+            { name: 'deploy.md', type: 'workflow', targetPath: wf, renderer: 'link' },
+            { name: 'deploy.md', type: 'agent', targetPath: ag, renderer: 'link' },
+        ]);
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['antigravity', 'claude-code'], 'global');
+        expect(listed).toHaveLength(2);
+        for (const a of listed)
+            expect(a.fullPaths).toHaveLength(1);
+    });
+    it('scope local se resuelve contra el projectRoot dado, no contra cwd', () => {
+        const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-proj-'));
+        const local = path_1.default.join(projectRoot, '.claude/skills/local-skill');
+        fs_1.default.mkdirSync(local, { recursive: true });
+        own([{ name: 'local-skill', type: 'skill', targetPath: local, renderer: 'link' }]);
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['claude-code'], 'local', projectRoot);
+        expect(listed.map((a) => a.name)).toEqual(['local-skill']);
+        // Y la ruta entregada es ABSOLUTA: antes era relativa, y se la pasaba
+        // tal cual a fs.rmSync.
+        expect(path_1.default.isAbsolute(listed[0].fullPaths[0])).toBe(true);
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
     });
     it('Gap C — an agent with a null global skill dir (copilot) at global scope skips cleanly instead of crashing', () => {
         // Copilot's skill.global is null (no user-level skill discovery mechanism —

package/dist/tests/core/provider-capability-guards.test.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: un provider que estructuralmente NO puede recibir un artefacto en
+// cierto scope (hoy: copilot en global — no tiene descubrimiento de skills a
+// nivel usuario) hacia TIRAR el plan entero, rompiendo el comando para todos
+// los demas agentes de la maquina.
+//
+// Sintoma confirmado contra el binario real:
+//     awm init -a claude-code -y && awm init -a copilot -y && awm update
+//     → Artifact reconciliation failed: skill global scope is not supported by Copilot
+//     exit=1
+// El comando moria ANTES del re-sync de hooks, asi que claude-code dejaba de
+// recibir actualizaciones — y no existe comando para deshabilitar un agente,
+// mientras `awm doctor` seguia diciendo "healthy".
+//
+// La causa era una asimetria de guarda clasica: el `.filter()` interno de
+// `assertCompleteSharedGroup` ya toleraba el caso, pero la linea de arriba
+// —que corre primero— no.
+const path_1 = __importDefault(require("path"));
+const install_planner_1 = require("../../src/core/install-planner");
+const skill = {
+    name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/reg/skills/using-awm',
+};
+describe('planInstall: un provider incapaz no puede romper el plan de los demas', () => {
+    it('scope global con copilot habilitado: planifica para los capaces y saltea copilot', () => {
+        const plan = (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['claude-code', 'copilot'],
+            enabledAgents: ['claude-code', 'copilot'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        });
+        const owners = plan.operations.flatMap((op) => op.owners);
+        expect(owners).toContain('claude-code');
+        expect(owners).not.toContain('copilot');
+    });
+    it('no tira aunque copilot este habilitado pero no seleccionado (el caso de awm update)', () => {
+        expect(() => (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['claude-code'],
+            enabledAgents: ['claude-code', 'copilot'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        })).not.toThrow();
+    });
+    it('peticion EXPLICITA de copilot en global: sigue tirando CON la explicacion', () => {
+        // Aca no hay a quien saltear — el usuario pidio justo esa combinacion, y
+        // lo que necesita es leer por que no se puede, no un exito silencioso.
+        expect(() => (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['copilot'],
+            enabledAgents: ['copilot'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        })).toThrow(/per-project|not supported/i);
+    });
+    it('copilot en scope local SI recibe el artefacto (su unico scope valido)', () => {
+        const plan = (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['copilot'],
+            enabledAgents: ['copilot'],
+            scope: 'local',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        });
+        expect(plan.operations).toHaveLength(1);
+        // `path.join`, no un literal con '/': `physicalTarget` construye la ruta con el
+        // separador de la plataforma, asi que en Windows el destino real es
+        // `.github\instructions` y la asercion POSIX-hardcodeada fallaba sobre un
+        // destino perfectamente correcto.
+        expect(plan.operations[0].targetPath).toContain(path_1.default.join('.github', 'instructions'));
+        expect(plan.operations[0].targetPath).toContain('using-awm.instructions.md');
+    });
+    it('el grupo compartido (opencode + codex) se sigue exigiendo completo', () => {
+        // La guarda no debe aflojar R14: ambos resuelven a ~/.agents/skills, asi
+        // que seleccionar solo uno seguiria siendo un cambio divergente.
+        expect(() => (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['codex'],
+            enabledAgents: ['codex', 'opencode'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        })).toThrow(/shared skill target/i);
+    });
+});

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

@@ -138,10 +138,18 @@ describe('planReconciliation (real, unmocked)', () => {
         // points nowhere — resolveBundleClosure just drops the missing dep.
         expect(names).toEqual(['ambient-skill', 'brainstorming', 'dangling-skill']);
     });
-    it('skips a bundle whose closure genuinely fails to resolve, without aborting reconciliation for the rest', () => {
-        // Malformed dependsOn (not an array) makes resolveBundleClosure throw
-        // when it tries to iterate it — a real "unresolvable closure" error,
-        // unlike a plain dangling name reference (see test above).
+    it('un dependsOn malformado ya no rompe nada: el campo invalido se ignora y el bundle instala', () => {
+        // Este test asertaba que un `dependsOn` no-array hacia TIRAR a
+        // `resolveBundleClosure` y que reconciliation lo salteaba. Desde que
+        // `discoverBundles` valida forma sobre el contenido del registry (que es
+        // input no confiable), ese campo se normaliza a `[]` en vez de
+        // propagarse hasta un `for...of` sobre un numero. O sea: la entrada ya
+        // no falla, y el bundle instala normalmente ignorando el campo roto.
+        //
+        // Es una mejora, no una regresion — antes UN archivo malformado en
+        // cualquier registry tumbaba `awm list`/`awm add` con un stack trace
+        // crudo. El `catch` de reconciliation sigue en su lugar como defensa en
+        // profundidad, pero esta entrada ya no lo ejercita.
         writeBundle(contentRoot, 'broken', 'baseline', ['broken-skill'], 5);
         addToCatalog(contentRoot, 'broken', 'baseline');
         const { planReconciliation } = require('../../src/core/reconciliation');
@@ -149,17 +157,9 @@ describe('planReconciliation (real, unmocked)', () => {
         expect(() => {
             plan = planReconciliation({ targets: ['claude-code'], roots: [contentRoot] });
         }).not.toThrow();
-        // The healthy bundles (baseline 'dev' + ambient 'ambient-x') still
-        // reconcile correctly.
         const names = plan.operations.map((op) => op.name).sort();
-        expect(names).toEqual(['ambient-skill', 'brainstorming']);
-        // The broken bundle is cleanly absent — no partial/broken entry for
-        // 'broken-skill' or any operation touching it.
-        expect(names).not.toContain('broken-skill');
-        expect(plan.operations.some((op) => op.sourcePath?.includes('broken'))).toBe(false);
-        // Applying the plan end-to-end still works (no dangling reference to
-        // the broken bundle leaked into the plan).
-        const { applyInstallPlan } = require('../../src/core/install-transaction');
-        expect(() => applyInstallPlan(plan)).not.toThrow();
+        // Los bundles sanos siguen reconciliando, y el que tenia el campo roto
+        // tambien — sin su dependencia invalida.
+        expect(names).toEqual(['ambient-skill', 'brainstorming', 'broken-skill']);
     });
 });

package/dist/tests/core/registry-manifest.test.js

@@ -69,7 +69,7 @@ describe('registry manifest (awm-registry.json)', () => {
     });
     it('registryNameForPath maps configured registries and returns null for unknown paths', () => {
         const m = load();
-        const regPath = path_1.default.join(m.REGISTRIES_DIR, 'team-acme', 'skills', 'x');
+        const regPath = path_1.default.join(m.registriesDir(), 'team-acme', 'skills', 'x');
         expect(m.registryNameForPath(regPath)).toBe('team-acme');
         expect(m.registryNameForPath('/somewhere/else')).toBeNull();
     });

package/dist/tests/core/renderers/canonical-agent.test.js

@@ -46,6 +46,42 @@ it('ignores provider-only mode while retaining canonical instructions', () => {
         instructions: expect.stringContaining('You do NOT write code directly.'),
     }); // verifies R8, R9
 });
+it('acepta una description en block scalar y la resuelve (regresion: rompia awm add -a codex)', () => {
+    // El parser exigia que TODA linea del frontmatter fuera `clave: valor`, asi
+    // que las lineas indentadas de un bloque lanzaban "invalid canonical agent
+    // frontmatter line" y abortaban el install de codex. Peor: discovery lee el
+    // MISMO archivo y (ya arreglado) mostraba la descripcion bien en el picker,
+    // asi que el crash llegaba despues de que la UI dijera que todo estaba OK.
+    const source = [
+        '---',
+        'name: bloque-agente',
+        'description: >-',
+        '  Primera linea de la descripcion',
+        '  y su continuacion.',
+        '---',
+        'Cuerpo de instrucciones.',
+    ].join('\n');
+    expect((0, canonical_agent_1.parseCanonicalAgent)(source)).toEqual({
+        name: 'bloque-agente',
+        description: 'Primera linea de la descripcion y su continuacion.',
+        instructions: 'Cuerpo de instrucciones.',
+    });
+});
+it('acepta un escalar plano multilinea y lo pliega (js-yaml lee exactamente esto)', () => {
+    // Ojo: una version previa de este test exigia un throw aca. Estaba mal —
+    // `description: x` seguido de una linea indentada es un escalar plano
+    // multilinea, YAML perfectamente valido, y js-yaml lo lee como
+    // "x suelta e indentada". Asertar el throw codificaba una divergencia con
+    // YAML, no un contrato.
+    const source = '---\nname: ok\ndescription: x\n  suelta e indentada\n---\nbody';
+    expect((0, canonical_agent_1.parseCanonicalAgent)(source).description).toBe('x suelta e indentada');
+});
+it('sigue rechazando una linea que no es ni clave ni continuacion indentada', () => {
+    // El fix no afloja la validacion estricta: una linea en columna 0 que no es
+    // `clave: valor` sigue siendo frontmatter malformado.
+    const source = '---\nname: ok\ndescription: x\nno soy un campo\n---\nbody';
+    expect(() => (0, canonical_agent_1.parseCanonicalAgent)(source)).toThrow('invalid canonical agent frontmatter line');
+});
 it.each([
     ['---\nname: Bad Name\ndescription: x\n---\nbody', 'invalid agent name'],
     ['---\nname: ok\ndescription:\n---\nbody', 'non-empty description'],

package/dist/tests/core/renderers/cursor-mdc.test.js

@@ -49,11 +49,18 @@ Body content.
     const rendered = (0, cursor_mdc_1.renderCursorMdc)(source);
     expect(rendered).toContain('description: "*starred description"');
 });
-it('throws rather than embedding a literal block-scalar indicator as the description', () => {
-    // Regression: a YAML block scalar (`description: >-` / `|-`) means the
-    // real text lives on the FOLLOWING indented lines, not on this line —
-    // the original code took the bare indicator itself as the description,
-    // which would have rendered the literal string ">-" into the .mdc file.
+it('resuelve un block scalar leyendo sus lineas indentadas, sin emitir el indicador literal', () => {
+    // Regression, en dos etapas:
+    //  1. La version original tomaba el indicador (`>-`) COMO la descripcion,
+    //     lo que habria escrito el literal ">-" dentro del .mdc.
+    //  2. El remedio siguiente lo detectaba pero lo colapsaba a '' (=> throw),
+    //     tratando una forma YAML valida como "descripcion ausente" — este
+    //     test codificaba ESE comportamiento parcial. Rompia `awm add
+    //     <bundle> -a cursor` contra un skill real del registry baseline
+    //     (extract-design-md), que usa exactamente esta forma.
+    // El contrato correcto, y el que se asserta ahora: leer el texto de las
+    // lineas indentadas. La intencion original del test — jamas emitir el
+    // indicador crudo — se conserva explicitamente abajo.
     const source = `---
 name: block-skill
 description: >-
@@ -63,16 +70,27 @@ description: >-
 
 Body content.
 `;
-    expect(() => (0, cursor_mdc_1.renderCursorMdc)(source)).toThrow('non-empty description');
+    const rendered = (0, cursor_mdc_1.renderCursorMdc)(source);
+    expect(rendered).toContain('description: This description spans multiple lines.');
+    expect(rendered).not.toContain('>-');
 });
 it('quotes a description containing a mid-string " #" (starts a YAML comment, truncating the rest)', () => {
     // Regression: the original YAML_UNSAFE regex only caught `#` at the START
     // of the string — a `#` preceded by whitespace ANYWHERE in a plain scalar
     // also starts a comment. Unquoted, "Use this #important skill" would
     // render as YAML that silently truncates to "Use this".
+    //
+    // El fuente esta ENTRECOMILLADO a proposito: ahi el `#` es literal y
+    // sobrevive al parseo, que es la unica manera de que un `#` llegue al
+    // renderer y haya algo que escapar. Antes el fixture usaba la forma SIN
+    // comillas, pero YAML dice que ahi ` #` abre un comentario — el lector lo
+    // trataba como texto (divergencia con cualquier parser real) y este test
+    // se apoyaba en esa divergencia. El contrato que el test realmente
+    // protege — nunca emitir un `#` sin comillas en la SALIDA — queda intacto
+    // y ahora se ejercita con una entrada que de verdad lo contiene.
     const source = `---
 name: hash-skill
-description: Use this #important skill
+description: "Use this #important skill"
 ---
 
 Body content.
@@ -81,6 +99,18 @@ Body content.
     expect(rendered).toContain('description: "Use this #important skill"');
     expect(rendered).not.toContain('description: Use this #important skill');
 });
+it('trata un " #" en una description SIN comillas como comentario YAML, igual que un parser real', () => {
+    const source = `---
+name: hash-plano
+description: Use this #important skill
+---
+
+Body content.
+`;
+    // js-yaml devuelve "Use this" para esta entrada: el comentario no es parte
+    // del valor. El renderer debe coincidir con esa lectura, no inventar texto.
+    expect((0, cursor_mdc_1.renderCursorMdc)(source)).toContain('description: Use this\n');
+});
 it('quotes a description containing an embedded null byte / control character instead of emitting it raw', () => {
     // Regression: an embedded control/null byte is invalid in a YAML plain
     // scalar regardless of position — the original code's YAML_UNSAFE regex

package/dist/tests/core/renderers/skill-source-block-scalar.test.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: `description: >-` (YAML block scalar) rompia `awm add <bundle>
+// -a copilot|cursor` contra un skill REAL del registry baseline
+// (skills/extract-design-md/SKILL.md, que usa exactamente esta forma).
+//
+// Un block scalar es YAML perfectamente valido: el indicador (`>-`, `|`, ...)
+// va en la linea de la clave y el texto real vive en las lineas indentadas
+// que siguen. El parser trataba el indicador como si fuera el valor, lo
+// detectaba como "no es una descripcion de verdad", y lo colapsaba a ''  —
+// que en `parseSkillSource` significa throw ("requires a non-empty
+// description") y en `readArtifactDescription` significa degradar en
+// silencio a descripcion vacia. Ninguno de los dos leia jamas las lineas
+// siguientes, que es donde estaba el texto todo el tiempo.
+const skill_source_1 = require("../../../src/core/renderers/skill-source");
+const cursor_mdc_1 = require("../../../src/core/renderers/cursor-mdc");
+const copilot_instructions_1 = require("../../../src/core/renderers/copilot-instructions");
+// Copia fiel del frontmatter de skills/extract-design-md/SKILL.md en
+// awm-baseline-registry — el caso real que dispara el bug, no un fixture
+// inventado.
+const realBlockScalarSkill = `---
+name: extract-design-md
+version: "1.0.1"
+description: >-
+  Extract a comprehensive design system (DESIGN.md) directly from frontend source
+  code — React, Vue, Svelte, Angular, plain HTML/CSS, or any web framework.
+---
+
+# Extract Design MD
+
+Body content.
+`;
+describe('parseSkillSource: descripciones en block scalar (regresion real del registry)', () => {
+    it('lee el texto de las lineas indentadas de un `>-`, en vez de tratar el indicador como el valor', () => {
+        const { description } = (0, skill_source_1.parseSkillSource)(realBlockScalarSkill);
+        expect(description).toBe('Extract a comprehensive design system (DESIGN.md) directly from frontend source ' +
+            'code — React, Vue, Svelte, Angular, plain HTML/CSS, or any web framework.');
+    });
+    it('pliega (folded, `>`) las lineas en espacios — no conserva los saltos de linea del fuente', () => {
+        const source = `---
+name: folded
+description: >
+  primera linea
+  segunda linea
+---
+
+Body.
+`;
+        expect((0, skill_source_1.parseSkillSource)(source).description).toBe('primera linea segunda linea');
+    });
+    it('conserva los saltos de linea de un literal (`|`) — semantica YAML distinta de `>`', () => {
+        const source = `---
+name: literal
+description: |
+  primera linea
+  segunda linea
+---
+
+Body.
+`;
+        expect((0, skill_source_1.parseSkillSource)(source).description).toBe('primera linea\nsegunda linea');
+    });
+    it('trata una linea en blanco dentro de un folded como separador de parrafo, no como espacio', () => {
+        const source = `---
+name: folded-parrafos
+description: >-
+  parrafo uno
+
+  parrafo dos
+---
+
+Body.
+`;
+        expect((0, skill_source_1.parseSkillSource)(source).description).toBe('parrafo uno\nparrafo dos');
+    });
+    it('no absorbe las claves siguientes del frontmatter como parte del bloque (corta en la primera linea no indentada)', () => {
+        const source = `---
+description: >-
+  solo esto pertenece al bloque
+name: no-soy-parte-del-bloque
+version: "9.9.9"
+---
+
+Body.
+`;
+        expect((0, skill_source_1.parseSkillSource)(source).description).toBe('solo esto pertenece al bloque');
+    });
+    it('resuelve el bloque igual con line endings CRLF (el repo es CRLF-tolerante y corre CI en windows-latest)', () => {
+        const source = '---\r\nname: crlf\r\ndescription: >-\r\n  linea uno\r\n  linea dos\r\n---\r\n\r\nBody aqui.\r\n';
+        expect((0, skill_source_1.parseSkillSource)(source).description).toBe('linea uno linea dos');
+    });
+    it('sigue lanzando si el bloque esta genuinamente vacio — un indicador sin lineas indentadas NO es una descripcion', () => {
+        const source = `---
+name: bloque-vacio
+description: >-
+name: otra-clave
+---
+
+Body.
+`;
+        expect(() => (0, skill_source_1.parseSkillSource)(source)).toThrow(/non-empty description/);
+    });
+});
+describe('renderers: el skill real del registry se renderiza para ambos providers', () => {
+    it('renderCursorMdc emite la descripcion real, nunca el indicador `>-` literal', () => {
+        const rendered = (0, cursor_mdc_1.renderCursorMdc)(realBlockScalarSkill);
+        expect(rendered).toContain('Extract a comprehensive design system');
+        // El modo de fallo que este test ancla: emitir el indicador crudo.
+        expect(rendered).not.toContain('description: >-');
+        expect(rendered).not.toContain('description: ""');
+    });
+    it('renderCopilotInstructions no crashea (no necesita la descripcion, pero parseSkillSource la exigia igual)', () => {
+        const rendered = (0, copilot_instructions_1.renderCopilotInstructions)(realBlockScalarSkill);
+        expect(rendered).toContain('applyTo: "**"');
+        expect(rendered).toContain('# Extract Design MD');
+    });
+});