agentic-workflow-manager 3.13.3 → 3.13.5

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 = [

package/dist/tests/core/frontmatter-description-vs-yaml.test.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Test DIFERENCIAL: readFrontmatterDescription (parser a mano, cero deps de
+// runtime) contra js-yaml (parser YAML real, devDependency solo de test).
+//
+// Por que existe: el repo parsea el frontmatter a mano a proposito (ver
+// core/export/transform.ts — "sin parser YAML a proposito, YAGNI, cero deps").
+// Esa decision es sostenible SOLO si algo verifica que la implementacion a
+// mano coincide con la semantica YAML real; si no, cada forma valida que el
+// parser casero no contempla es un bug esperando a un skill que la use. Ya
+// paso dos veces: (1) un block scalar (`description: >-`) se colapsaba a
+// vacio, rompiendo `awm add -a cursor|copilot` y abortando `awm export`
+// entero contra un skill real del registry; (2) este mismo test diferencial
+// descubrio que un escalar single-quoted no deshacia el escape YAML de `'`
+// (duplicado: `''`), devolviendo "it''s" en vez de "it's".
+//
+// js-yaml es devDependency: NO entra en el bundle que instalan los usuarios.
+// La regla de cero dependencias de runtime queda intacta — de hecho este test
+// es lo que la hace defendible.
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const discovery_1 = require("../../src/core/discovery");
+/** Cada caso es un bloque de frontmatter cuyo `description` debe resolverse
+ *  IGUAL que como lo hace un parser YAML real. Sin valores esperados
+ *  hardcodeados a proposito: la referencia es js-yaml, asi que el test no
+ *  puede "envejecer" hacia una expectativa equivocada. */
+const CASES = [
+    ['folded (>)', 'description: >\n  a\n  b'],
+    ['folded strip (>-)', 'description: >-\n  a\n  b'],
+    ['folded keep (>+)', 'description: >+\n  a\n  b'],
+    ['literal (|)', 'description: |\n  a\n  b'],
+    ['literal strip (|-)', 'description: |-\n  a\n  b'],
+    ['folded con parrafos', 'description: >-\n  a\n\n  b'],
+    ['literal con parrafos', 'description: |-\n  a\n\n  b'],
+    ['bloque seguido de otra clave', 'description: >-\n  solo\nname: x'],
+    ['bloque con indent 4', 'description: >-\n    a\n    b'],
+    ['bloque con indent explicito', 'description: >2\n  a\n  b'],
+    ['bloque de una sola linea', 'description: >-\n  sola'],
+    ['bloque con colon adentro', 'description: >-\n  clave: valor'],
+    ['bloque con hash adentro', 'description: >-\n  a #no-es-comentario'],
+    ['plain', 'description: hola mundo'],
+    ['plain con guion', 'description: usa - guiones'],
+    ['double-quoted con colon', 'description: "hola: mundo"'],
+    ['double-quoted con comilla escapada', 'description: "dice \\"hola\\""'],
+    ['double-quoted con \\n', 'description: "a\\nb"'],
+    ['double-quoted con backslash', 'description: "c:\\\\\\\\ruta"'],
+    ['single-quoted con apostrofe escapado', "description: 'it''s aqui'"],
+    ['single-quoted con doble apostrofe', "description: 'a''''b'"],
+    ['single-quoted con colon', "description: 'clave: valor'"],
+    ['double-quoted con em-dash', 'description: "em — dash"'],
+    // Casos que una revision adversarial encontro y los tests a mano no cubrian.
+    ['folded con lineas MAS indentadas (no se pliegan)', 'description: >-\n  intro\n    - item uno\n    - item dos\n  outro'],
+    ['folded con indentacion irregular', 'description: >\n  foo\n   bar\n  baz'],
+    ['indicador con comentario final', 'description: >- # nota al margen\n  el texto real'],
+    ['literal con comentario final', 'description: |- # nota\n  linea'],
+    ['clave description indentada NO gana sobre la real', 'metadata:\n  description: nota interna\ndescription: la verdadera'],
+    ['description dentro del contenido de otro bloque', 'example: |\n  description: falsa\ndescription: la verdadera'],
+    ['plain con comentario final', 'description: hola mundo # un comentario'],
+    ['plain con hash pegado (NO es comentario)', 'description: usar C# y F#'],
+    ['plain multilinea (se pliega como folded)', 'description: primera\n  segunda\n  tercera'],
+    ['quoted con hash adentro (literal)', 'description: "tiene # adentro"'],
+    // Segunda tanda de revision adversarial: espacios, blancos consecutivos y
+    // escalares entrecomillados que cierran en una linea posterior.
+    ['blancos consecutivos en folded', 'description: >-\n  a\n\n\n  b'],
+    ['espacios finales dentro de un folded', 'description: >-\n  a   \n  b'],
+    ['linea solo-espacios dentro de un folded', 'description: >-\n  a\n   \n  b'],
+    ['double-quoted multilinea', 'description: "hola\n  mundo"'],
+    ['single-quoted multilinea', "description: 'hola\n  mundo'"],
+    ['double-quoted con comentario final', 'description: "x" # comentario'],
+    ['single-quoted con comentario final', "description: 'y' # comentario"],
+    ['single-quoted con apostrofe y comentario', "description: 'it''s aqui' # nota"],
+];
+/** Formas que YAML RECHAZA: no hay valor correcto que devolver, y devolver el
+ *  indicador crudo como si fuera la descripcion seria peor que no devolver
+ *  nada (se publicaria en el artefacto). El contrato aca es '' — que hace
+ *  fallar fuerte a parseSkillSource y claudeAiTransform. */
+const INVALID_CASES = [
+    ['indicador con indent 0', 'description: >0\n  a'],
+    ['indicador con indent de 2 digitos', 'description: >12\n  a'],
+    ['indicador con basura pegada', 'description: >-basura\n  a'],
+    ['indicador con comentario sin espacio', 'description: >-#c\n  a'],
+];
+describe('readFrontmatterDescription coincide con un parser YAML real (js-yaml)', () => {
+    it.each(CASES)('%s', (_name, frontmatter) => {
+        const parsed = js_yaml_1.default.load(frontmatter);
+        // Guard del propio fixture: si js-yaml no lo lee como string, el caso
+        // esta mal escrito y el test seria vacuo — que falle fuerte.
+        expect(typeof parsed.description).toBe('string');
+        const expected = parsed.description.trim();
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).toBe(expected);
+    });
+    it.each(INVALID_CASES)('%s: YAML lo rechaza, nosotros devolvemos vacio (nunca el indicador crudo)', (_name, frontmatter) => {
+        // Guard del fixture: si js-yaml LO ACEPTARA, el caso esta mal clasificado
+        // y este test seria vacuo — que falle fuerte.
+        expect(() => js_yaml_1.default.load(frontmatter)).toThrow();
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).toBe('');
+    });
+    it('resuelve el SKILL.md real del registry igual que js-yaml (extract-design-md, el caso que origino el bug)', () => {
+        // Forma exacta del skill real de awm-baseline-registry que rompia
+        // `awm add -a cursor|copilot` y `awm export frontend`.
+        const frontmatter = [
+            '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.',
+            'allowed-tools:',
+            '  - "Bash"',
+        ].join('\n');
+        const expected = (js_yaml_1.default.load(frontmatter).description).trim();
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).toBe(expected);
+        // Y no absorbio la clave siguiente ni sus items indentados.
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).not.toContain('allowed-tools');
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).not.toContain('Bash');
+    });
+});

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

@@ -8,6 +8,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const steps_1 = require("../../../src/core/init/steps");
 const providers_1 = require("../../../src/providers");
+const context_1 = require("../../../src/core/diagnostics/context");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
@@ -141,6 +142,60 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
         expect((0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installBundle).toHaveBeenCalled();
     });
+    // Regression for the confirmed production bug: `awm init -a copilot` crashed
+    // 100% of the time with "machine.devCore: skill global scope is not
+    // supported by Copilot...", rolling back the ENTIRE init transaction (even
+    // project-local artifacts like AGENTS.md). Root cause: Copilot has no
+    // global skill directory (providerFor('copilot').skill.global === null),
+    // so gatherMachine's devCorePresent was permanently false for it, and
+    // stepDevCore fell through to installBundle at global scope on every run
+    // — an install that always throws. Fixed in diagnostics/context.ts:
+    // devCore.present is now reported `true` (N/A treated as satisfied) when
+    // skill.global is null, so this step's existing skip guard applies
+    // naturally.
+    //
+    // Unlike the rest of this describe block (which hand-builds `machine()`
+    // fixtures — a fine choice for exercising stepDevCore's own skip-guard
+    // logic in isolation), this test calls the REAL `gatherContext` (the
+    // function diagnostics/context.ts's fix actually lives in) with an
+    // isolated HOME/AWM_HOME, and feeds ITS real output into stepDevCore.
+    // That's deliberate: an earlier version of this test hand-built
+    // `devCore: { present: true, brokenLinks: [] }` directly and asserted
+    // against it, which only re-verified stepDevCore's pre-existing skip
+    // guard — reverting the context.ts fix left that version GREEN because it
+    // never called the fixed code at all. This version goes RED on revert:
+    // gatherContext would then report `devCore.present: false` for Copilot,
+    // stepDevCore would fall through to `installBundle`, and the assertions
+    // below (`action === 'skipped'`, `installBundle` not called) would fail.
+    it('devCore skips cleanly (never calls installBundle) for an agent with no global skill directory (copilot) — via real gatherContext', () => {
+        expect((0, providers_1.providerFor)('copilot').skill.global).toBeNull();
+        const tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-steps-copilot-devcore-'));
+        const originalHome = process.env.HOME;
+        const originalAwmHome = process.env.AWM_HOME;
+        try {
+            process.env.HOME = tmpHome;
+            process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+            const baselineBundle = bundle('dev-core', 'baseline', ['brainstorming']);
+            const ctx = (0, context_1.gatherContext)({ cwd: tmpHome, bundles: [baselineBundle], agent: 'copilot' });
+            const a = spies();
+            const r = (0, steps_1.stepDevCore)(deps({ machine: ctx.machine, project: null }, a, {
+                agent: 'copilot', enabledAgents: ['copilot'], bundles: [baselineBundle],
+            }));
+            expect(r.action).toBe('skipped');
+            expect(a.installBundle).not.toHaveBeenCalled();
+        }
+        finally {
+            fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+            if (originalHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = originalHome;
+            if (originalAwmHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = originalAwmHome;
+        }
+    });
     it('ambient installs only missing wanted', () => {
         const a = spies();
         const m = machine();

package/dist/tests/core/journal/process.test.js

@@ -11,7 +11,31 @@ const process_1 = require("../../../src/core/journal/process");
 const paths_1 = require("../../../src/core/paths");
 describe('process identity', () => {
     test('spawnStructured produce ProcessRef con tupla completa (R2.1, R4.7)', async () => {
-        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nonce-abc');
+        // Reintento de INSTANCIA completa (no solo de la consulta), a proposito:
+        // esta misma linea fallo 2 veces reales consecutivas en windows-latest
+        // CI, la segunda vez YA con el presupuesto interno de pidExistsNative
+        // ampliado a 10 intentos/100ms (~900ms de espera real dentro de
+        // refIsAlive) — evidencia de que NO es (solo) latencia de visibilidad
+        // de OpenProcess bajo carga: un proceso genuinamente vivo no deberia
+        // seguir siendo invisible tras casi un segundo de reintentos. Apunta
+        // en cambio a que el hijo mismo puede terminar genuinamente muy
+        // temprano en este runner (imagen windows-2025-vs2026, sospecha no
+        // confirmable sin Windows real: AV/Defender interviniendo un `node -e`
+        // recien lanzado bajo carga pesada de CI). pidExistsNative reintenta
+        // la MISMA consulta sobre el MISMO pid — si ese pid ya esta
+        // genuinamente muerto, reintentar la consulta jamas ayuda. Este loop
+        // reintenta el SPAWN entero: un intento NUEVO puede sobrevivir donde
+        // el anterior no lo hizo. Si los 3 intentos mueren temprano, el
+        // ultimo `expect` de abajo sigue fallando fuerte — no enmascara una
+        // regresion real de refIsAlive.
+        let { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nonce-abc');
+        for (let attempt = 1; attempt < 3 && !(0, process_1.refIsAlive)(ref); attempt++) {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* ya ausente */ }
+            ({ child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nonce-abc'));
+        }
         expect(ref.pid).toBe(child.pid);
         expect(ref.spawnNonce).toBe('nonce-abc');
         expect(typeof ref.startTime).toBe('string');
@@ -253,6 +277,35 @@ describe('process identity (win32, mockeado — sin windows real disponible en e
         expect((0, process_1.refIsAlive)(fakeRef)).toBe(true); // NUNCA declara muerte por el ESRCH transitorio de los primeros 2 intentos
         expect(killSpy).toHaveBeenCalledTimes(3);
     });
+    test('pidExistsNative absorbe una carrera transitoria mas larga que el presupuesto original — arranque en frio del primer spawn del job (regresion #2: misma falla real, mismo test, tras el fix de 3x50ms ya mergeado)', () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        let calls = 0;
+        const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => {
+            calls++;
+            // El pid tarda 9 intentos en "aparecer" — mas alla del presupuesto
+            // anterior (3 intentos) pero dentro del ampliado (10 intentos).
+            if (calls < 9) {
+                const err = new Error('transient');
+                err.code = 'ESRCH';
+                throw err;
+            }
+            return true;
+        });
+        const fakeRef = { pid: 424243, startTime: 'x', spawnNonce: 'n', argvDigest: 'd', processGroup: 424243, psArgsDigest: 'x' };
+        expect((0, process_1.refIsAlive)(fakeRef)).toBe(true);
+        expect(killSpy).toHaveBeenCalledTimes(9);
+    });
+    test('pidExistsNative declara muerte solo tras agotar el presupuesto ampliado (10 intentos) — un ESRCH sostenido nunca se lee como vivo', () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => {
+            const err = new Error('gone');
+            err.code = 'ESRCH';
+            throw err;
+        });
+        const fakeRef = { pid: 424244, startTime: 'x', spawnNonce: 'n', argvDigest: 'd', processGroup: 424244, psArgsDigest: 'x' };
+        expect((0, process_1.refIsAlive)(fakeRef)).toBe(false);
+        expect(killSpy).toHaveBeenCalledTimes(10);
+    });
     test('refIsAlive en win32 NUNCA declara muerte por un error que no sea ESRCH (ej. EPERM: el pid existe pero sin permiso de senializarlo) (R2.1)', () => {
         Object.defineProperty(process, 'platform', { value: 'win32' });
         jest.spyOn(process, 'kill').mockImplementation(() => {

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