agentic-workflow-manager 3.13.4 → 3.13.6

package/dist/tests/core/artifact-name-containment.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// SECURITY regression: artifact names taken VERBATIM from a registry's
+// `bundle.json` were joined onto the provider's install directory with no
+// validation and no containment check, so `path.join(dir, name)` escaped the
+// directory entirely:
+//
+//   path.join('~/.claude/skills', '../../.ssh/authorized_keys')
+//     => '~/.ssh/authorized_keys'
+//
+// Impact went well past a stray write. `replaceArtifact` does
+// `fs.rmSync(targetPath, {recursive:true, force:true})` before linking, so a
+// name of `../../.ssh` RECURSIVELY DELETED the user's real ~/.ssh and replaced
+// it with a symlink into the attacker's registry clone. Writing
+// `~/.config/autostart/*.desktop` gives code execution at next login.
+//
+// Reachable from `awm add`, `awm sync`, `awm registry add` and `awm init` —
+// and note that `awm init` auto-installs the first bundle declaring
+// `scope: "baseline"` across ALL roots, so a malicious registry does not even
+// need the user to pick its bundle.
+//
+// Every other registry-facing reader in this codebase already rejects `..` and
+// separators (readRegistriesConfig, readRegistryManifest, readProfile). The
+// bundle path was the one that never got the guard.
+const artifact_name_1 = require("../../src/core/artifact-name");
+describe('assertSafeArtifactName: contencion de nombres provenientes del registry', () => {
+    const TRAVERSAL = [
+        ['padre relativo', '../evil'],
+        ['padre profundo', '../../../../../../tmp/escape'],
+        ['ssh del usuario', '../../.ssh/authorized_keys'],
+        ['separador posix', 'sub/dir'],
+        ['separador windows', 'sub\\dir'],
+        ['absoluto posix', '/etc/passwd'],
+        ['absoluto windows', 'C:\\Windows\\System32\\x'],
+        ['unc windows', '\\\\server\\share'],
+        ['componente punto', '.'],
+        ['componente doble punto', '..'],
+        ['punto embebido', 'a/../b'],
+    ];
+    it.each(TRAVERSAL)('rechaza %s', (_name, candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)(candidate, 'skill')).toThrow(/unsafe|invalid/i);
+    });
+    it.each([
+        ['vacio', ''],
+        ['solo espacios', '   '],
+        ['byte NUL', 'evil\u0000.md'],
+        ['byte de control', 'evil\u0001name'],
+    ])('rechaza %s', (_name, candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+    });
+    it.each([
+        ['CON', 'CON'], ['con minuscula', 'con'], ['con extension', 'CON.md'],
+        ['AUX', 'AUX'], ['NUL', 'NUL'], ['PRN', 'PRN'],
+        ['COM1', 'COM1'], ['LPT1', 'LPT1'],
+    ])('rechaza el nombre reservado de Windows %s', (_name, candidate) => {
+        // Reservados en TODA plataforma a proposito: el registry es contenido
+        // compartido entre equipos, y un nombre que rompe solo en las maquinas
+        // Windows del equipo es peor que uno que se rechaza en todas.
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+    });
+    it.each([
+        ['punto final', 'skill.'],
+        ['espacio final', 'skill '],
+    ])('rechaza %s (Windows los recorta en silencio y cambia el destino)', (_name, candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+    });
+    it.each([
+        'development-process',
+        'skill_con_guion_bajo',
+        'v1.2-migration',
+        'extract-design-md',
+        'a',
+        'UPPER-case-Mixed',
+        'skill.md',
+    ])('acepta el nombre legitimo %s', (candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(true);
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)(candidate, 'skill')).not.toThrow();
+    });
+    it('el mensaje de error nombra el tipo y el valor ofensivo, para que el operador pueda ubicarlo', () => {
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)('../../.ssh', 'skill'))
+            .toThrow(/skill/);
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)('../../.ssh', 'skill'))
+            .toThrow(/\.\.\/\.\.\/\.ssh/);
+    });
+});

package/dist/tests/core/context/agents-md-single-slot.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: `managed-block.ts` soporta UN bloque gestionado por archivo, y
+// tanto el contexto de cursor/copilot (`inject()`, cuyo destino ES el AGENTS.md
+// del proyecto) como la guia de proyecto de codex (`injectProject()`) apuntan al
+// mismo `<projectRoot>/AGENTS.md`. El que corriera ultimo ganaba:
+//
+//     awm init -a copilot  → AGENTS.md 140 lineas (contexto AWM completo)
+//     awm init -a codex    → AGENTS.md   6 lineas (solo PROJECT_GUIDANCE)
+//     awm init -a copilot  → 140 otra vez ... y asi oscilando
+//
+// Para Copilot ese archivo es su UNICO canal de entrega, asi que un init de
+// codex lo dejaba literalmente sin contexto. El contenido de cursor/copilot es
+// un SUPERCONJUNTO — termina con el mismo PROJECT_GUIDANCE — asi que pisarlo
+// siempre es perder informacion.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const codex_agents_1 = require("../../../src/core/context/strategies/codex-agents");
+const managed_block_1 = require("../../../src/core/context/managed-block");
+const providers_1 = require("../../../src/providers");
+describe('AGENTS.md: un solo slot, dos escritores', () => {
+    let projectRoot;
+    let agentsMd;
+    beforeEach(() => {
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-agentsmd-'));
+        agentsMd = path_1.default.join(projectRoot, 'AGENTS.md');
+    });
+    afterEach(() => fs_1.default.rmSync(projectRoot, { recursive: true, force: true }));
+    const strategy = () => new codex_agents_1.CodexAgentsStrategy();
+    it('injectProject de codex NO pisa un bloque que ya cubre PROJECT_GUIDANCE', () => {
+        // Primero se deja que codex escriba, para capturar su PROJECT_GUIDANCE
+        // sin depender de un export interno.
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        const guidance = (0, managed_block_1.managedBlockBody)(fs_1.default.readFileSync(agentsMd, 'utf-8'));
+        // Ahora se simula lo que dejan cursor/copilot: contexto AWM completo
+        // que TERMINA con esa misma guia — un superconjunto.
+        const rich = `# Contexto AWM completo\n\nmuchas lineas de contexto\n\n${guidance}`;
+        fs_1.default.writeFileSync(agentsMd, `<!-- AWM:START -->\n${rich}\n<!-- AWM:END -->\n`);
+        const before = fs_1.default.readFileSync(agentsMd, 'utf-8');
+        // Un `awm init -a codex` posterior debe dejarlo intacto: antes lo
+        // reemplazaba por las 6 lineas de la guia, y para Copilot ese archivo es
+        // su unico canal de entrega.
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        expect(fs_1.default.readFileSync(agentsMd, 'utf-8')).toBe(before);
+        expect(fs_1.default.readFileSync(agentsMd, 'utf-8')).toContain('muchas lineas de contexto');
+    });
+    it('codex SI escribe la guia cuando el archivo no existe todavia', () => {
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        expect(fs_1.default.existsSync(agentsMd)).toBe(true);
+        expect((0, managed_block_1.managedBlockBody)(fs_1.default.readFileSync(agentsMd, 'utf-8'))).toBeTruthy();
+    });
+    it('codex es idempotente: una segunda pasada no cambia el archivo', () => {
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        const first = fs_1.default.readFileSync(agentsMd, 'utf-8');
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        expect(fs_1.default.readFileSync(agentsMd, 'utf-8')).toBe(first);
+    });
+    it('el contenido que el usuario tiene fuera del bloque gestionado se conserva', () => {
+        fs_1.default.writeFileSync(agentsMd, '# Mis notas\n\nEsto es mio.\n');
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        const after = fs_1.default.readFileSync(agentsMd, 'utf-8');
+        expect(after).toContain('# Mis notas');
+        expect(after).toContain('Esto es mio.');
+    });
+});

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

@@ -53,13 +53,13 @@ describe('regenerateGlobalContext', () => {
     it('returns empty when no config-instructions agent has a config file', () => {
         seedRegistry();
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(regenerateGlobalContext()).toEqual([]);
+        expect(regenerateGlobalContext(['opencode'])).toEqual([]);
     });
     it('skips an agent whose config exists but has no AWM sentinel', () => {
         seedRegistry();
         seedOpencode(['docs/rules.md']); // sin el sentinel
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(regenerateGlobalContext(['opencode'])).toEqual([{ agent: 'opencode', action: 'skipped' }]);
         expect(fs_1.default.existsSync(contextPath())).toBe(false); // no se crea el archivo
     });
     it('refreshes a stale agent (sentinel present, materialized file absent) and recreates the file', () => {
@@ -67,7 +67,7 @@ describe('regenerateGlobalContext', () => {
         seedOpencode([contextPath()]); // sentinel presente, pero el archivo no existe → stale
         expect(fs_1.default.existsSync(contextPath())).toBe(false);
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'refreshed' }]);
+        expect(regenerateGlobalContext(['opencode'])).toEqual([{ agent: 'opencode', action: 'refreshed' }]);
         expect(fs_1.default.existsSync(contextPath())).toBe(true);
         expect(fs_1.default.readFileSync(contextPath(), 'utf-8')).toContain('USING-AWM-BODY');
     });
@@ -75,9 +75,9 @@ describe('regenerateGlobalContext', () => {
         seedRegistry();
         seedOpencode([contextPath()]);
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        regenerateGlobalContext(); // 1ª pasada: stale → refreshed, crea el archivo
+        regenerateGlobalContext(['opencode']); // 1ª pasada: stale → refreshed, crea el archivo
         const mtime1 = fs_1.default.statSync(contextPath()).mtimeMs;
-        const second = regenerateGlobalContext(); // 2ª pasada: ya injected → fresh
+        const second = regenerateGlobalContext(['opencode']); // 2ª pasada: ya injected → fresh
         expect(second).toEqual([{ agent: 'opencode', action: 'fresh' }]);
         expect(fs_1.default.statSync(contextPath()).mtimeMs).toBe(mtime1); // archivo intacto
     });
@@ -90,8 +90,8 @@ describe('regenerateGlobalContext', () => {
         fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.com/baseline.git' }], null, 2) + '\n');
         seedOpencode([contextPath()]);
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(() => regenerateGlobalContext()).not.toThrow();
-        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(() => regenerateGlobalContext(['opencode'])).not.toThrow();
+        expect(regenerateGlobalContext(['opencode'])).toEqual([{ agent: 'opencode', action: 'skipped' }]);
     });
     it('skips agent when contextStatus throws an unexpected error', () => {
         seedRegistry();
@@ -100,7 +100,38 @@ describe('regenerateGlobalContext', () => {
         const { InjectionOrchestrator } = require('../../../src/core/context/orchestrator');
         const brokenOrch = new InjectionOrchestrator();
         brokenOrch.contextStatus = () => { throw new Error('unexpected orchestrator error'); };
-        expect(regenerateGlobalContext(undefined, brokenOrch)).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(regenerateGlobalContext(['opencode'], brokenOrch)).toEqual([{ agent: 'opencode', action: 'skipped' }]);
         expect(fs_1.default.existsSync(contextPath())).toBe(false); // installContext never called
     });
+    // Regresion: el filtro exigia `type === 'config-instructions'`, o sea que
+    // SOLO se regeneraba OpenCode. Para codex/cursor/copilot
+    // (`managed-agents-md`) `awm update` era un no-op silencioso — ni siquiera
+    // un aviso — y la unica forma de refrescar el contexto era volver a correr
+    // `awm init`. Y como doctor reporta `status: healthy` / exit 0 ante un
+    // contexto 'stale', un AGENTS.md desactualizado era invisible para
+    // cualquier gate de CI que mirara el codigo de salida.
+    it('codex (managed-agents-md con globalPath) ya no se saltea por tipo', () => {
+        seedRegistry();
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        const seen = [];
+        const orch = {
+            contextStatus: (op) => { seen.push(op.agent); return 'absent'; },
+            installContext: () => undefined,
+        };
+        regenerateGlobalContext(['codex'], orch);
+        expect(seen).toEqual(['codex']);
+    });
+    it('cursor y copilot se saltean: no tienen archivo de contexto GLOBAL que regenerar', () => {
+        seedRegistry();
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        const seen = [];
+        const orch = {
+            contextStatus: (op) => { seen.push(op.agent); return 'absent'; },
+            installContext: () => undefined,
+        };
+        // Su `injection.globalPath` es null — su contexto es project-local, y
+        // eso no es trabajo de una regeneracion global.
+        expect(regenerateGlobalContext(['cursor', 'copilot'], orch)).toEqual([]);
+        expect(seen).toEqual([]);
+    });
 });

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

@@ -4,7 +4,7 @@ const checks_1 = require("../../../src/core/diagnostics/checks");
 function healthyMachine() {
     return {
         registryCache: { present: true, gitState: 'clean' },
-        hook: { present: true, degraded: false },
+        hook: { present: true, degraded: false, applicable: true },
         devCore: { present: true, brokenLinks: [] },
         ambient: { wanted: [], installed: [] },
         contextInjection: [],
@@ -16,6 +16,7 @@ function healthyProject() {
         root: '/repo/belanz',
         profile: { present: true, extensions: ['frontend'] },
         activeBundles: { expected: ['frontend-craft'], linked: ['frontend-craft'], broken: [] },
+        orphanLinks: { repairable: [], dead: [] },
         sensors: { present: true },
         constitution: { present: true },
         context: { present: true, file: 'CLAUDE.md' },
@@ -80,12 +81,12 @@ describe('runChecks — machine.cli', () => {
 describe('runChecks — machine.hook / devCore', () => {
     it('hook degraded → warn', () => {
         const m = healthyMachine();
-        m.hook = { present: true, degraded: true };
+        m.hook = { present: true, degraded: true, applicable: true };
         expect(byId({ machine: m, project: null }, 'machine.hook').status).toBe('warn');
     });
     it('hook absent → missing + awm init', () => {
         const m = healthyMachine();
-        m.hook = { present: false };
+        m.hook = { present: false, applicable: true };
         const c = byId({ machine: m, project: null }, 'machine.hook');
         expect(c.status).toBe('missing');
         expect(c.remedy).toEqual({ kind: 'command', value: 'awm init' });
@@ -162,7 +163,7 @@ describe('machineChecks — global skill integrity', () => {
         return {
             machine: {
                 registryCache: { present: true, gitState: 'clean' },
-                hook: { present: true, degraded: false },
+                hook: { present: true, degraded: false, applicable: true },
                 devCore: { present: true, brokenLinks: [] },
                 ambient: { wanted: [], installed: [] },
                 contextInjection: [],
@@ -194,8 +195,15 @@ describe('computeProviderOverall (Task 9)', () => {
             checks: states.map((state, i) => ({ id: CHECK_IDS[i % CHECK_IDS.length], state })),
         };
     }
-    it('healthy when every check is in an ok/pending/warn state', () => {
-        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'shared', 'pending-trust', 'stale'])])).toBe('healthy');
+    it('healthy when every check is in an ok/pending state', () => {
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'shared', 'pending-trust'])])).toBe('healthy');
+    });
+    it('degraded cuando algun check esta stale — un contexto viejo tiene que verse en el exit code', () => {
+        // Antes `stale` quedaba fuera de los estados degradantes, asi que doctor
+        // imprimia ⚠ junto a `status: healthy` y exit 0. Un AGENTS.md
+        // desactualizado (o pisado por otro provider) era invisible para
+        // cualquier gate de CI que mirara el codigo de salida.
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'stale'])])).toBe('degraded');
     });
     it('degrades on a single broken/missing/absent/unsupported/conflict check', () => {
         expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'absent'])])).toBe('degraded');

package/dist/tests/core/diagnostics/provider-tier.test.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //    `contextStatus` about 'global' for these providers always resolved to
 //    'absent' regardless of whether the local injection actually succeeded.
 // 3. `skillsGlobalCheck`'s renderer-awareness fix (deferred Task 4.3 finding):
-//    `classifyGlobalSkills` only ever sees symlinks, so a rendered format
+//    `classifySkillLinks` only ever sees symlinks, so a rendered format
 //    (cursor-mdc, copilot-instructions) always scanned as "0 broken" and
 //    reported a false-green 'healthy' regardless of what was actually on
 //    disk. Non-'link' renderers now report presence-only, honestly.
@@ -174,9 +174,9 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
         const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
         fs_1.default.mkdirSync(rulesDir, { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(rulesDir, 'development-process.mdc'), '---\ndescription: dev process\nalwaysApply: true\n---\n\nBody.');
-        // classifyGlobalSkills only ever sees symlinks (`if (!lst.isSymbolicLink()) continue;`)
+        // classifySkillLinks only ever sees symlinks (`if (!lst.isSymbolicLink()) continue;`)
         // — a real scan over rulesDir would find nothing here either. Stubbed explicitly so the
-        // test proves the FIX (renderer-gating), not an accident of what classifyGlobalSkills does.
+        // test proves the FIX (renderer-gating), not an accident of what classifySkillLinks does.
         const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
         const facts = gatherProviderChecks(['cursor'], scanSkills);

package/dist/tests/core/diagnostics/rendered-artifact-visibility.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: el ESCRITOR estampa la extension del renderer sobre el nombre
+// (`using-awm.mdc`, `using-awm.instructions.md`, `development-process.toml`)
+// pero los LECTORES de diagnostico buscaban el nombre pelado. Consecuencia para
+// Cursor y Copilot: nada figuraba jamas como instalado, asi que
+//   - `awm init` NUNCA era idempotente — reinstalaba el baseline entero en cada
+//     corrida, dejando 2 directorios de backup sin podar por corrida;
+//   - `awm doctor` mostraba `✖ dev-core` / `✖ active bundles` de forma
+//     permanente, con un remedio (`awm init` / `awm sync`) que no podia
+//     satisfacerlo nunca.
+// Y lo mismo para los artefactos `agent` de claude-code — el provider POR
+// DEFECTO — porque su installName es `<n>.md` y el lector mapeaba solo el caso
+// `.toml` de codex.
+//
+// Estos tests recorren la misma funcion que usa el escritor
+// (`renderedFilename`), asi que lector y escritor no pueden volver a discrepar.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const registry_1 = require("../../../src/core/renderers/registry");
+const install_planner_1 = require("../../../src/core/install-planner");
+describe('renderedFilename: una sola fuente de verdad para el nombre en disco', () => {
+    it.each([
+        ['link deja el nombre tal cual', 'using-awm', 'link', 'using-awm'],
+        ['link conserva el .md del installName', 'development-process.md', 'link', 'development-process.md'],
+        ['cursor-mdc', 'using-awm', 'cursor-mdc', 'using-awm.mdc'],
+        ['cursor-mdc recorta el .md antes de estampar', 'using-awm.md', 'cursor-mdc', 'using-awm.mdc'],
+        ['copilot-instructions', 'using-awm', 'copilot-instructions', 'using-awm.instructions.md'],
+        ['codex-agent-toml', 'development-process.md', 'codex-agent-toml', 'development-process.toml'],
+    ])('%s', (_n, installName, renderer, expected) => {
+        expect((0, registry_1.renderedFilename)(installName, renderer)).toBe(expected);
+    });
+    it('no usa path.parse().name — un nombre con puntos internos no se trunca', () => {
+        // `path.parse('v1.2-migration').name` === 'v1', lo que perderia
+        // `2-migration` y podria colisionar con otro skill llamado `v1`.
+        expect((0, registry_1.renderedFilename)('v1.2-migration', 'cursor-mdc')).toBe('v1.2-migration.mdc');
+    });
+});
+describe('el lector de diagnostico ve lo que el escritor dejo en disco', () => {
+    let projectRoot;
+    beforeEach(() => {
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rendered-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    // El invariante que importa: el nombre que el escritor produce y el que el
+    // lector busca salen de la MISMA funcion. Se verifica sobre el destino real
+    // que planifica `physicalTarget`, no sobre una reconstruccion a mano.
+    it.each([
+        ['cursor'], ['copilot'], ['claude-code'], ['codex'], ['opencode'], ['antigravity'],
+    ])('%s: el basename del destino planificado coincide con renderedFilename', (agent) => {
+        const { targetPath, renderer } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, agent, 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe((0, registry_1.renderedFilename)('using-awm', renderer));
+    });
+    it('cursor: el destino termina en .mdc (el lector que buscaba el nombre pelado nunca lo encontraba)', () => {
+        const { targetPath } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, 'cursor', 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe('using-awm.mdc');
+        expect(fs_1.default.existsSync(path_1.default.join(path_1.default.dirname(targetPath), 'using-awm'))).toBe(false);
+    });
+    it('copilot: el destino termina en .instructions.md', () => {
+        const { targetPath } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, 'copilot', 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe('using-awm.instructions.md');
+    });
+});

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

@@ -105,8 +105,17 @@ describe('Artifact Discovery', () => {
             fs_1.default.readFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
             expect((0, discovery_1.readArtifactDescription)('/missing/SKILL.md')).toBe('');
         });
-        it('returns empty string for a block scalar description indicator', () => {
+        it('resuelve un block scalar leyendo sus lineas indentadas (antes descartaba el texto y devolvia vacio)', () => {
+            // Este test afirmaba `''` sobre un fixture que contiene literalmente
+            // "actual text" — codificaba la degradacion silenciosa, no un
+            // contrato. Un `description: >-` es YAML valido y su texto vive en
+            // las lineas indentadas siguientes; descartarlo dejaba el skill sin
+            // descripcion en todo el discovery del CLI.
             fs_1.default.readFileSync.mockReturnValue('---\ndescription: >-\n  actual text\n---\n');
+            expect((0, discovery_1.readArtifactDescription)('/any/SKILL.md')).toBe('actual text');
+        });
+        it('sigue devolviendo vacio si el indicador de block scalar no tiene lineas indentadas (genuinamente sin descripcion)', () => {
+            fs_1.default.readFileSync.mockReturnValue('---\ndescription: >-\nname: otra-clave\n---\n');
             expect((0, discovery_1.readArtifactDescription)('/any/SKILL.md')).toBe('');
         });
     });

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

@@ -1,7 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const js_yaml_1 = __importDefault(require("js-yaml"));
 const transform_1 = require("../../../src/core/export/transform");
 const FM = (lines) => `---\n${lines.join('\n')}\n---\nBody line.\n`;
+/** Reparsea el frontmatter EXPORTADO con un YAML real y devuelve su
+ *  `description`. Lanza si la salida no es YAML valido — que es justamente lo
+ *  que queremos que falle fuerte, en vez de asertar sobre el texto crudo y no
+ *  enterarnos de que emitimos algo que ningun parser puede leer. */
+function descriptionOf(exported) {
+    const fm = exported.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!fm)
+        throw new Error('la salida no tiene bloque de frontmatter');
+    const parsed = js_yaml_1.default.load(fm[1]);
+    if (typeof parsed.description !== 'string')
+        throw new Error('description ausente o no-string en la salida');
+    return parsed.description;
+}
 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."']);
@@ -16,18 +33,25 @@ describe('claudeAiTransform', () => {
         const out = (0, transform_1.claudeAiTransform)(input, 'x');
         expect(out).toContain(`description: "Does things. ${(0, transform_1.DEFERENCE_LINE)('x')}"`);
     });
+    // NOTA sobre el estilo de la salida: el transform ya no conserva el estilo de
+    // comillas del fuente — emite SIEMPRE un escalar double-quoted via
+    // JSON.stringify, sea cual sea la forma de entrada (plano, entrecomillado,
+    // block scalar, multilinea). Antes habia una rama por forma, y cada vez que
+    // el lector aprendia una forma nueva el escritor quedaba atras: asi se
+    // colaron una deference line enterrada en medio de una descripcion
+    // multilinea y otra tragada entera por un `#` de comentario. Un solo camino
+    // hace imposible esa clase de divergencia. El contrato que estos tests
+    // protegen — YAML valido que conserva descripcion + deference line — se
+    // cumple igual, y se verifica reparseando la salida con js-yaml mas abajo.
     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')}`);
+        expect(out).toContain(`description: ${JSON.stringify(`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, "''")}'`);
+        expect(out).toContain(`description: ${JSON.stringify(`Does things. ${(0, transform_1.DEFERENCE_LINE)('x')}`)}`);
     });
     it('appends the deference line inside a double-quoted description with trailing whitespace', () => {
         const input = FM(['name: x', 'portable: true', 'description: "Does things."   ']);
@@ -50,26 +74,91 @@ describe('claudeAiTransform', () => {
     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('resuelve una descripcion en block scalar y le anexa la deference line (antes abortaba el export del bundle entero)', () => {
+        // Regresion real: esto lanzaba, y runExport propaga el throw — asi que UN
+        // skill del registry baseline con esta forma valida (extract-design-md)
+        // hacia fallar `awm export frontend` COMPLETO, no solo ese skill.
+        const out = (0, transform_1.claudeAiTransform)(FM(['name: x', 'description: >', '  folded text', '  segunda linea']), 'x');
+        const descLine = out.split('\n').find((l) => l.startsWith('description:'));
+        expect(descLine).toBe(`description: ${JSON.stringify(`folded text segunda linea ${(0, transform_1.DEFERENCE_LINE)('x')}`)}`);
+        // Las lineas indentadas del bloque se consumieron: no quedan sueltas.
+        expect(out).not.toContain('  folded text');
+        expect(out).not.toContain('description: >');
+    });
+    it('no absorbe las claves siguientes del frontmatter al consumir el bloque', () => {
+        const out = (0, transform_1.claudeAiTransform)(FM(['description: >-', '  solo esto', 'name: sigue-viva']), 'x');
+        expect(out).toContain('name: sigue-viva');
+        const descLine = out.split('\n').find((l) => l.startsWith('description:'));
+        expect(descLine).toContain('solo esto');
+        expect(descLine).not.toContain('sigue-viva');
+    });
+    it('sigue lanzando si el block scalar no tiene contenido', () => {
+        expect(() => (0, transform_1.claudeAiTransform)(FM(['name: x', 'description: >-']), 'x')).toThrow(/no content/);
+    });
+    it('lanza si description esta presente pero vacia (sin valor y sin bloque)', () => {
+        expect(() => (0, transform_1.claudeAiTransform)(FM(['name: x', 'description:']), 'x')).toThrow(/description is empty/);
     });
-    it('escapes an apostrophe in the deference line when appending to a single-quoted description', () => {
+    it('resuelve un block scalar CON comentario final sin perder el contenido (regresion: guarda por prefijo vs match completo)', () => {
+        // La guarda de la rama de bloque usaba un prefijo (/^[>|]/) mientras el
+        // resolver exigia match COMPLETO del indicador. Con `>- # nota` entraban en
+        // desacuerdo: se publicaba el indicador como descripcion y las lineas de
+        // contenido REALES se borraban del artefacto exportado, en silencio.
+        const out = (0, transform_1.claudeAiTransform)(FM(['name: x', 'description: >- # nota al margen', '  el texto real']), 'x');
+        const descLine = out.split('\n').find((l) => l.startsWith('description:'));
+        expect(descLine).toContain('el texto real');
+        expect(descLine).not.toContain('# nota al margen');
+        expect(out).not.toContain('description: >-');
+    });
+    it('lanza ante un indicador de bloque malformado en vez de emitir YAML invalido', () => {
+        // `>-basura` lo rechaza el propio YAML. Tratarlo como escalar plano emitiria
+        // `description: >-basura ...`, invalido porque `>` abre un indicador.
+        expect(() => (0, transform_1.claudeAiTransform)(FM(['name: x', 'description: >-basura', '  texto']), 'x'))
+            .toThrow(/malformed block scalar indicator/);
+    });
+    it('conserva la linea en blanco que separa el bloque de la clave siguiente', () => {
+        const out = (0, transform_1.claudeAiTransform)(FM(['description: >-', '  el texto', '', 'name: x']), 'x');
+        expect(out).toMatch(/description: .*\n\nname: x/);
+    });
+    it('no deja que el apostrofe de la deference line rompa el escalar emitido', () => {
+        // DEFERENCE_LINE siempre contiene un apostrofe ("registry's"). El fix
+        // original lo doblaba ('') porque la salida era single-quoted; hoy la
+        // salida es double-quoted, donde el apostrofe es un caracter comun. Lo
+        // que el test protege no es la convencion de comillas sino que el
+        // resultado sea YAML bien formado con el texto intacto — se verifica
+        // reparseando con js-yaml en vez de inspeccionar comillas a ojo.
         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)', () => {
+        expect(descriptionOf(out)).toBe(`Diagrams and flowcharts. ${(0, transform_1.DEFERENCE_LINE)('mermaid')}`);
+        expect(descriptionOf(out)).toContain("registry's mermaid skill");
+    });
+    it('resuelve un escalar entrecomillado con comentario final en vez de lanzar', () => {
+        // Antes lanzaba. Pero `description: "x" # nota` es YAML valido y js-yaml lo
+        // lee como "x": el comentario no forma parte del valor. Lanzar obligaba al
+        // autor a tocar un SKILL.md que no tenia nada malo.
         const input = FM(['name: x', 'portable: true', 'description: "Does things." # a comment']);
-        expect(() => (0, transform_1.claudeAiTransform)(input, 'x')).toThrow(/trailing content|comment/i);
+        expect(descriptionOf((0, transform_1.claudeAiTransform)(input, 'x'))).toBe(`Does things. ${(0, transform_1.DEFERENCE_LINE)('x')}`);
+    });
+    describe('round-trip: la salida se reparsea con un YAML real (par lector+escritor)', () => {
+        // Los tests del lector, por si solos, no habrian detectado que el ESCRITOR
+        // quedaba atras cuando el lector aprendia una forma nueva. Estos casos
+        // pasan cada forma por el transform y REPARSEAN el resultado, que es donde
+        // se ve si la deference line sobrevivio y si el YAML sigue siendo valido.
+        it.each([
+            ['plano', ['description: Does things.']],
+            ['plano multilinea', ['description: primera parte', '  y su continuacion']],
+            ['plano con comentario final', ['description: hola mundo # nota del autor']],
+            ['single-quoted', ["description: 'con apostrofe: it''s'"]],
+            ['double-quoted', ['description: "con dos puntos: si"']],
+            ['folded', ['description: >-', '  primera', '  segunda']],
+            ['literal', ['description: |-', '  primera', '  segunda']],
+            ['folded con comentario en el indicador', ['description: >- # nota', '  el texto']],
+        ])('%s', (_name, descLines) => {
+            const out = (0, transform_1.claudeAiTransform)(FM(['name: x', 'portable: true', ...descLines]), 'x');
+            const desc = descriptionOf(out); // lanza si la salida no es YAML valido
+            // La deference line es la razon de existir de este transform: nunca puede
+            // perderse en un comentario ni quedar sepultada en el medio del texto.
+            expect(desc.endsWith((0, transform_1.DEFERENCE_LINE)('x'))).toBe(true);
+        });
     });
     it('cleans intra-registry paths in the body', () => {
         const md = [