agentic-workflow-manager 9.0.2 → 9.1.0

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

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const body_1 = require("../../../src/core/process/body");
+const body = `
+# Ejemplo
+
+## Objetivo
+
+G — Llevar una idea hasta una rama cerrada.
+
+## Cuándo aplica
+
+Cuando hay una tarea de desarrollo sin plan previo.
+
+## Estructura
+
+- SG-1 — Diseñar
+  - OP-1.1 — Elicitar requisitos
+  - OP-1.2 — Escribir el design doc
+- SG-2 — Ejecutar
+  - OP-2.1 — Implementar por tasks
+
+## Ruteo
+
+| Cuándo | Estado requerido | Va a | Termina en |
+|---|---|---|---|
+| No hay design doc | | OP-1.1 | SG-1 |
+| Design doc aprobado | SG-1 | OP-2.1 | SG-2 |
+
+## Terminación
+
+finishing-a-development-branch
+
+## Sin verificar
+
+- Que el usuario tenga un registry propio instalado.
+`;
+describe('parseProcessBody', () => {
+    it('extrae las seis secciones', () => {
+        const r = (0, body_1.parseProcessBody)(body, 'p');
+        expect(r.diagnostics).toEqual([]);
+        expect(r.model.objective).toBe('G — Llevar una idea hasta una rama cerrada.');
+        expect(r.model.appliesWhen).toBe('Cuando hay una tarea de desarrollo sin plan previo.');
+        expect(r.model.termination).toBe('finishing-a-development-branch');
+        expect(r.model.unverified).toEqual(['Que el usuario tenga un registry propio instalado.']);
+    });
+    it('descompone Estructura en SG-# con sus OP-#', () => {
+        expect((0, body_1.parseProcessBody)(body, 'p').model.structure).toEqual([
+            { id: 'SG-1', text: 'Diseñar', operations: [
+                    { id: 'OP-1.1', text: 'Elicitar requisitos' }, { id: 'OP-1.2', text: 'Escribir el design doc' }
+                ] },
+            { id: 'SG-2', text: 'Ejecutar', operations: [{ id: 'OP-2.1', text: 'Implementar por tasks' }] },
+        ]);
+    });
+    it('lee Ruteo con sus cuatro columnas, incluida la vacía', () => {
+        expect((0, body_1.parseProcessBody)(body, 'p').model.routing).toEqual([
+            { when: 'No hay design doc', requiredState: '', goesTo: 'OP-1.1', endsAt: 'SG-1' },
+            { when: 'Design doc aprobado', requiredState: 'SG-1', goesTo: 'OP-2.1', endsAt: 'SG-2' },
+        ]);
+    });
+    it('conserva las filas de Ruteo como datos, sin evaluarlas ni colapsarlas', () => {
+        // WCP16 Deferred Choice: la condición se evalúa al llegar a la decisión,
+        // leyendo el estado real del proyecto. El parser no puede precomputar cuál
+        // fila gana — si lo hiciera, `show --json` emitiría una decisión ya tomada.
+        const r = (0, body_1.parseProcessBody)(body, 'p').model;
+        expect(r.routing).toHaveLength(2);
+        expect(Object.keys(r)).not.toContain('activeRoute');
+        expect(JSON.stringify(r.routing)).toContain('No hay design doc');
+    });
+    it.each(['## Objetivo', '## Ruteo', '## Terminación'])('rechaza si falta %s', (heading) => {
+        const r = (0, body_1.parseProcessBody)(body.replace(heading, '## Otra cosa'), 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/missing/i);
+    });
+    it('rechaza una tabla de Ruteo con número de columnas equivocado', () => {
+        const r = (0, body_1.parseProcessBody)(body.replace('| No hay design doc | | OP-1.1 | SG-1 |', '| No hay design doc | OP-1.1 |'), 'p');
+        expect(r.model).toBeUndefined();
+    });
+    it('rechaza un id de operación que no cuelga de su subobjetivo', () => {
+        const r = (0, body_1.parseProcessBody)(body.replace('OP-2.1', 'OP-9.1'), 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/OP-9\.1/);
+    });
+    it('nunca lanza ante entrada basura', () => {
+        for (const junk of ['', '## Objetivo', '| | | |', '#'.repeat(500)]) {
+            expect(() => (0, body_1.parseProcessBody)(junk, 'p')).not.toThrow();
+        }
+    });
+    it('rechaza un heading de nivel 2 repetido en vez de fusionarlo', () => {
+        // Un `## Ruteo` duplicado no debe fusionar sus líneas con la primera
+        // aparición: si lo hiciera, la fila de cabecera de la segunda tabla
+        // ("| Cuándo | ... |") caería en un índice no-cero del array fusionado
+        // y `parseRouting` la confundiría con una fila de datos — corrupción
+        // silenciosa, sin diagnóstico. Esto es especialmente grave porque este
+        // parser procesa contenido no confiable de registries externos.
+        const duped = `
+## Objetivo
+
+G — Llevar una idea hasta una rama cerrada.
+
+## Cuándo aplica
+
+Cuando hay una tarea de desarrollo sin plan previo.
+
+## Estructura
+
+- SG-1 — Diseñar
+  - OP-1.1 — Elicitar requisitos
+
+## Ruteo
+
+| Cuándo | Estado requerido | Va a | Termina en |
+|---|---|---|---|
+| No hay design doc | | OP-1.1 | SG-1 |
+
+## Ruteo
+
+| Cuándo | Estado requerido | Va a | Termina en |
+|---|---|---|---|
+| Otra condición | | OP-1.1 | SG-1 |
+
+## Terminación
+
+finishing-a-development-branch
+
+## Sin verificar
+
+- Que el usuario tenga un registry propio instalado.
+`;
+        const r = (0, body_1.parseProcessBody)(duped, 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/duplicate/i);
+    });
+    it('parsea un heading con una racha larga de espacios finales sin colgarse (ReDoS)', () => {
+        // Regresión: `splitSections` matcheaba headings con `/^##\s+(.+?)\s*$/`.
+        // El grupo perezoso `(.+?)` seguido de `\s*` sobre una clase que lo
+        // solapa (`.` ⊃ `\s`) es cuadrático — ver AGENTS.md
+        // "regex-cuantificador-adyacente-a-clase-que-lo-solapa". Una sola línea
+        // `## `-prefijada con una racha larga de espacios finales (ni siquiera
+        // maliciosa, un typo alcanza) colgaba el proceso. El fix usa captura
+        // greedy a fin-de-línea (`(.*)$`, sin cuantificador adyacente) y hace
+        // `.trim()` en código. Este test prueba que el parseo completo del
+        // documento sigue siendo lineal, no solo el regex aislado.
+        const longTrailingSpace = '## Objetivo' + ' '.repeat(50000) + 'x';
+        const doc = body.replace('## Objetivo', longTrailingSpace);
+        const t0 = Date.now();
+        const r = (0, body_1.parseProcessBody)(doc, 'p');
+        const elapsed = Date.now() - t0;
+        expect(elapsed).toBeLessThan(500);
+        // El heading matcheado debe llevar el trim aplicado en código, no en el regex.
+        expect(r.diagnostics.join(' ')).toMatch(/missing required section "## Objetivo"/);
+    });
+    it('ignora una línea "## " (solo espacio, sin nombre) como contenido ordinario, sin abrir una sección fantasma', () => {
+        // Regresión del fix de ReDoS: la regex vieja `/^##\s+(.+?)\s*$/` exigía
+        // al menos un carácter no-blanco capturado, así que una línea "##"
+        // seguida solo de espacio NUNCA matcheaba como heading. La regex nueva
+        // `/^##\s+(.*)$/` + trim() sí puede capturar "" — sin el guard de
+        // finding-1, esa línea abriría una sección "" fantasma y desviaría lo
+        // que sigue (aquí, una fila real de la tabla de Ruteo) hacia ella,
+        // dejando `parseProcessBody` "exitoso" pero con datos perdidos y CERO
+        // diagnósticos. La línea debe tratarse como contenido ordinario de la
+        // sección abierta (`## Ruteo`), donde `parseRouting` ya la ignora por
+        // no empezar con "|".
+        const strayHeading = body.replace('## Ruteo\n\n| Cuándo | Estado requerido | Va a | Termina en |', '## Ruteo\n\n## \n\n| Cuándo | Estado requerido | Va a | Termina en |');
+        expect(strayHeading).not.toBe(body); // guard: el replace debe haber encontrado el punto de inserción
+        const r = (0, body_1.parseProcessBody)(strayHeading, 'p');
+        expect(r.diagnostics).toEqual([]);
+        expect(r.model.routing).toEqual([
+            { when: 'No hay design doc', requiredState: '', goesTo: 'OP-1.1', endsAt: 'SG-1' },
+            { when: 'Design doc aprobado', requiredState: 'SG-1', goesTo: 'OP-2.1', endsAt: 'SG-2' },
+        ]);
+    });
+    it('reconoce un separador de tabla con colons de alineación GFM (|:---|:---:|) sin fabricar una fila', () => {
+        // finding-2: el detector viejo `/^-{1,}$/.test(cells.join(''))` solo
+        // reconoce separadores de dashes puros. `|:---|:---:|:---:|:---:|` es
+        // sintaxis GFM estándar de alineación de columnas (muy probable si el
+        // autor del registry usó cualquier formateador de tablas markdown) y
+        // NO era reconocida — la fila colaba como dato fabricado con celdas
+        // literales como ":---". El fix la reconoce por celda con un regex
+        // anclado `^:?-+:?$` (lineal, sin riesgo ReDoS).
+        const gfmAligned = body.replace('|---|---|---|---|', '|:---|:---:|:---:|:---:|');
+        expect(gfmAligned).not.toBe(body);
+        const r = (0, body_1.parseProcessBody)(gfmAligned, 'p');
+        expect(r.diagnostics).toEqual([]);
+        expect(r.model.routing).toEqual([
+            { when: 'No hay design doc', requiredState: '', goesTo: 'OP-1.1', endsAt: 'SG-1' },
+            { when: 'Design doc aprobado', requiredState: 'SG-1', goesTo: 'OP-2.1', endsAt: 'SG-2' },
+        ]);
+        // Ninguna fila fabricada a partir del separador (p.ej. celdas ":---").
+        expect(JSON.stringify(r.model.routing)).not.toContain(':--');
+    });
+    it.each(['Objetivo', 'Cuándo aplica', 'Terminación'])('rechaza %s presente pero con contenido vacío', (heading) => {
+        // A diferencia del test "rechaza si falta %s" (heading ausente por
+        // completo), acá el heading `## ${heading}` SÍ está presente pero no
+        // tiene contenido no-blanco debajo antes del siguiente `##` — el
+        // rechazo lo produce el chequeo `value === ''` sobre `paragraph()`,
+        // no `splitSections`, y ese camino no tenía cobertura.
+        const emptied = body.replace(new RegExp(`## ${heading}\\n\\n[^#]*`), `## ${heading}\n\n   \n\n`);
+        expect(emptied).not.toBe(body);
+        const r = (0, body_1.parseProcessBody)(emptied, 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(new RegExp(`"${heading}" is empty`));
+    });
+    it('rechaza una sección de prosa que excede el largo máximo', () => {
+        // finding-1 QA: ninguna sección de texto libre tenía cota de largo —
+        // un `## Objetivo` de 10MB en un registry no confiable se aceptaba
+        // sin rechazo ni truncamiento. `MAX_SECTION_LENGTH` en body.ts cierra
+        // ese hueco para las secciones de prosa (Objetivo/Cuándo
+        // aplica/Terminación).
+        const overlong = body.replace('G — Llevar una idea hasta una rama cerrada.', 'x'.repeat(5001));
+        expect(overlong).not.toBe(body);
+        const r = (0, body_1.parseProcessBody)(overlong, 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/"Objetivo" must be at most 5000 characters/);
+    });
+    it('rechaza un texto de SG-# que excede el largo máximo de ítem', () => {
+        // Mismo hueco que la sección de prosa, pero para los ítems
+        // estructurales (texto de SG-#/OP-#, celdas de Ruteo, entradas de
+        // "Sin verificar"), acotados por `MAX_ITEM_LENGTH` — más corto que
+        // `MAX_SECTION_LENGTH` porque son título-cortos por contrato.
+        const overlong = body.replace('- SG-1 — Diseñar', `- SG-1 — ${'x'.repeat(501)}`);
+        expect(overlong).not.toBe(body);
+        const r = (0, body_1.parseProcessBody)(overlong, 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/"SG-1" text must be at most 500 characters/);
+    });
+    it('rechaza un SG-# duplicado en Estructura', () => {
+        // finding-3: a diferencia de la validación OP-# <-> SG-# (que sí
+        // rechaza una pertenencia inconsistente), un SG-# repetido pasaba en
+        // silencio y producía un `structure` con dos entradas compartiendo el
+        // mismo `id` — inconsistente para cualquier consumidor que indexe por
+        // id. Mismo patrón `problems` que el resto del archivo.
+        const dupedSg = body.replace('- SG-1 — Diseñar\n  - OP-1.1 — Elicitar requisitos\n  - OP-1.2 — Escribir el design doc\n- SG-2 — Ejecutar', '- SG-1 — Diseñar\n  - OP-1.1 — Elicitar requisitos\n  - OP-1.2 — Escribir el design doc\n- SG-1 — Diseñar otra vez\n- SG-2 — Ejecutar');
+        expect(dupedSg).not.toBe(body);
+        const r = (0, body_1.parseProcessBody)(dupedSg, 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/duplicate.*SG-1/i);
+    });
+});

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

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/process/discover.test.ts
+const discover_1 = require("../../../src/core/process/discover");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const FIXTURE = `---
+awm: process-model
+schema: 1
+name: NAME
+status: draft
+entry_point: true
+terminates_to: none
+created: 2026-08-23
+updated: 2026-08-23
+---
+
+## Objetivo
+
+G — Objetivo.
+
+## Cuándo aplica
+
+Siempre.
+
+## Estructura
+
+- SG-1 — Uno
+  - OP-1.1 — Hacer
+
+## Ruteo
+
+| Cuándo | Estado requerido | Va a | Termina en |
+|---|---|---|---|
+| Al empezar | | OP-1.1 | SG-1 |
+
+## Terminación
+
+none
+
+## Sin verificar
+
+- Nada.
+`;
+function registry(root, skills) {
+    for (const [name, content] of Object.entries(skills)) {
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills', name), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills', name, 'SKILL.md'), content);
+    }
+    return root;
+}
+describe('discoverProcessModels', () => {
+    let tmp;
+    beforeEach(() => { tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-process-discover-')); });
+    afterEach(() => { fs_1.default.rmSync(tmp, { recursive: true, force: true }); });
+    it('encuentra solo los SKILL.md con el discriminador', () => {
+        const root = registry(path_1.default.join(tmp, 'r1'), {
+            'mi-proceso': FIXTURE.replace('NAME', 'mi-proceso'),
+            'skill-normal': '---\nname: skill-normal\ndescription: otra cosa\n---\n\n# Normal\n',
+        });
+        const r = (0, discover_1.discoverProcessModels)([root]);
+        expect(r.models.map((m) => m.name)).toEqual(['mi-proceso']);
+        expect(r.diagnostics).toEqual([]);
+    });
+    it('un modelo roto no impide descubrir los sanos', () => {
+        const root = registry(path_1.default.join(tmp, 'r2'), {
+            'sano': FIXTURE.replace('NAME', 'sano'),
+            'roto': FIXTURE.replace('NAME', 'roto').replace('schema: 1', 'schema: cero'),
+        });
+        const r = (0, discover_1.discoverProcessModels)([root]);
+        expect(r.models.map((m) => m.name)).toEqual(['sano']);
+        expect(r.diagnostics).toHaveLength(1);
+    });
+    it('deduplica por name entre registries y lo reporta', () => {
+        const a = registry(path_1.default.join(tmp, 'a'), { 'dup': FIXTURE.replace('NAME', 'dup') });
+        const b = registry(path_1.default.join(tmp, 'b'), { 'dup': FIXTURE.replace('NAME', 'dup') });
+        const r = (0, discover_1.discoverProcessModels)([a, b]);
+        expect(r.models).toHaveLength(1);
+        expect(r.diagnostics.join(' ')).toMatch(/duplicates/i);
+    });
+    it('sin registries devuelve vacío sin diagnósticos', () => {
+        expect((0, discover_1.discoverProcessModels)([])).toEqual({ models: [], diagnostics: [] });
+    });
+    it('nunca lanza con un root inexistente', () => {
+        expect(() => (0, discover_1.discoverProcessModels)([path_1.default.join(tmp, 'no-existe')])).not.toThrow();
+    });
+    it('un `skills` roto (archivo en vez de directorio) no impide seguir, y queda diagnosticado', () => {
+        const root = path_1.default.join(tmp, 'r3');
+        fs_1.default.mkdirSync(root, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills'), 'no soy un directorio');
+        let r;
+        expect(() => { r = (0, discover_1.discoverProcessModels)([root]); }).not.toThrow();
+        expect(r.models).toEqual([]);
+        expect(r.diagnostics).toHaveLength(1);
+        expect(r.diagnostics[0]).toContain(root);
+    });
+    it('un SKILL.md roto (directorio en vez de archivo) no impide seguir, y queda diagnosticado', () => {
+        const root = path_1.default.join(tmp, 'r4');
+        const skillMd = path_1.default.join(root, 'skills', 'roto', 'SKILL.md');
+        fs_1.default.mkdirSync(skillMd, { recursive: true });
+        let r;
+        expect(() => { r = (0, discover_1.discoverProcessModels)([root]); }).not.toThrow();
+        expect(r.models).toEqual([]);
+        expect(r.diagnostics).toHaveLength(1);
+        expect(r.diagnostics[0]).toContain(skillMd);
+        expect(r.diagnostics[0]).toMatch(/cannot read/);
+    });
+    it('un SKILL.md simbolico apuntando fuera del registry no se lee: ni modelo ni contenido filtrado en diagnósticos', () => {
+        const root = path_1.default.join(tmp, 'r5');
+        const skillDir = path_1.default.join(root, 'skills', 'malicioso');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        // Archivo "sensible" FUERA de la raíz del registry — simula ~/.ssh/id_rsa u otro
+        // archivo local legible por el usuario que ejecuta `awm`.
+        const secretDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-outside-registry-'));
+        const secretFile = path_1.default.join(secretDir, 'id_rsa');
+        const SECRET_MARKER = 'SUPER-SECRET-PRIVATE-KEY-CONTENT-DO-NOT-LEAK';
+        fs_1.default.writeFileSync(secretFile, `-----BEGIN OPENSSH PRIVATE KEY-----\n${SECRET_MARKER}\n-----END OPENSSH PRIVATE KEY-----\n`);
+        const skillMd = path_1.default.join(skillDir, 'SKILL.md');
+        fs_1.default.symlinkSync(secretFile, skillMd);
+        let r;
+        expect(() => { r = (0, discover_1.discoverProcessModels)([root]); }).not.toThrow();
+        // Ningún modelo se construye a partir del symlink.
+        expect(r.models).toEqual([]);
+        // Se reporta el problema, pero SOLO nombrando el path — nunca el contenido del
+        // archivo apuntado. El nombre del archivo secreto en sí (id_rsa) sirve como proxy
+        // de "esto no debería aparecer en diagnósticos" tanto como el contenido.
+        expect(r.diagnostics).toHaveLength(1);
+        expect(r.diagnostics[0]).toContain(skillMd);
+        expect(r.diagnostics[0]).toMatch(/symbolic link/i);
+        const allDiagnosticsText = r.diagnostics.join('\n');
+        expect(allDiagnosticsText).not.toContain(SECRET_MARKER);
+        expect(allDiagnosticsText).not.toContain('BEGIN OPENSSH PRIVATE KEY');
+        fs_1.default.rmSync(secretDir, { recursive: true, force: true });
+    });
+});

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = require("../../../src/core/process/model");
+const valid = `---
+awm: process-model
+schema: 1
+name: ejemplo-proceso
+status: draft
+entry_point: true
+terminates_to: none
+created: 2026-08-23
+updated: 2026-08-23
+---
+
+# Ejemplo
+`;
+describe('parseProcessFrontmatter', () => {
+    it('acepta el modelo canónico', () => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid, 'skills/x/SKILL.md');
+        expect(r.diagnostics).toEqual([]);
+        expect(r.model).toEqual(expect.objectContaining({
+            schema: 1, name: 'ejemplo-proceso', status: 'draft', entryPoint: true, terminatesTo: 'none',
+        }));
+    });
+    it('no infiere: sin el discriminador no es un modelo', () => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('awm: process-model\n', ''), 'skills/x/SKILL.md');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics).toEqual([]); // no es un error: es "no es un modelo"
+    });
+    it('se detiene ante un schema más nuevo en vez de leerlo como el anterior', () => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('schema: 1', 'schema: 2'), 'skills/x/SKILL.md');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/newer/i);
+    });
+    it.each(['0', '-1', '1.5', 'uno'])('rechaza schema no-entero-positivo %s', (bad) => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('schema: 1', `schema: ${bad}`), 'skills/x/SKILL.md');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics).not.toEqual([]);
+    });
+    it.each(['active', 'draft'])('admite status %s', (s) => {
+        expect((0, model_1.parseProcessFrontmatter)(valid.replace('status: draft', `status: ${s}`), 'p').model?.status).toBe(s);
+    });
+    it('rechaza un status inventado', () => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('status: draft', 'status: published'), 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/status/);
+    });
+    it('rechaza un campo desconocido en vez de ignorarlo', () => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('created:', 'api_token: ghp_x\ncreated:'), 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/unknown field/i);
+    });
+    it('rechaza un name que no es slug', () => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('name: ejemplo-proceso', 'name: ../../etc/passwd'), 'p');
+        expect(r.model).toBeUndefined();
+    });
+    it('nunca lanza ante entrada basura', () => {
+        for (const junk of ['', '---\n', '---\n\x00\n---\n', 'no frontmatter']) {
+            expect(() => (0, model_1.parseProcessFrontmatter)(junk, 'p')).not.toThrow();
+        }
+    });
+    it.each(['si', 'True', '1', 'yes'])('rechaza un entry_point que no es true/false: %s', (bad) => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('entry_point: true', `entry_point: ${bad}`), 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/"entry_point" must be true or false/);
+    });
+    it.each(['../../etc/passwd', 'None', 'Foo-Bar', 'has spaces'])('rechaza un terminates_to que no es slug ni "none": %s', (bad) => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace('terminates_to: none', `terminates_to: ${bad}`), 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(/"terminates_to" must be a lowercase slug or "none"/);
+    });
+    it.each(['created', 'updated'])('rechaza un %s con formato de fecha inválido', (field) => {
+        const r = (0, model_1.parseProcessFrontmatter)(valid.replace(`${field}: 2026-08-23`, `${field}: 23-08-2026`), 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(new RegExp(`${field}.*YYYY-MM-DD`));
+    });
+    it.each(['name', 'status', 'entry_point', 'terminates_to', 'created', 'updated'])('rechaza si falta el campo requerido %s', (field) => {
+        const withoutField = valid.split('\n').filter((line) => !line.startsWith(`${field}:`)).join('\n');
+        const r = (0, model_1.parseProcessFrontmatter)(withoutField, 'p');
+        expect(r.model).toBeUndefined();
+        expect(r.diagnostics.join(' ')).toMatch(new RegExp(`"${field}" is required`));
+    });
+});

package/dist/tests/core/process/no-regression.test.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/process/no-regression.test.ts
+const collect_1 = require("../../../src/core/dashboard/collect");
+const discover_1 = require("../../../src/core/process/discover");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('R7 — ausencia de modelos y aislamiento', () => {
+    let root;
+    let home;
+    const realHome = process.env.HOME;
+    const realAwmHome = process.env.AWM_HOME;
+    beforeEach(() => {
+        root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-process-noreg-'));
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-process-home-'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        // R7.4: ningún test toca el ~/.awm real.
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+    });
+    afterEach(() => {
+        if (realHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = realHome;
+        if (realAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = realAwmHome;
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    });
+    it('sin modelos, el snapshot conserva las nueve secciones en orden', () => {
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: '2026-08-23T00:00:00.000Z' });
+        expect(snapshot.sections.map((s) => s.id)).toEqual(['machine', 'project', 'planning', 'execution', 'qa', 'docs', 'retro', 'history', 'processes']);
+        expect(snapshot.schema).toBe(2);
+        expect(snapshot.sections.find((s) => s.id === 'processes')).toEqual(expect.objectContaining({ availability: 'not_applicable', items: [] }));
+    });
+    it('el descubridor no toca el ~/.awm real', () => {
+        // contentRoots() (usado por default por discoverProcessModels) lee
+        // AWM_HOME dinámicamente en cada llamada — con AWM_HOME apuntando al
+        // tmpdir de este test, sin modelos de proceso instalados ahí, esto
+        // no debe lanzar. (Se descartó una aserción sobre `.awm/process-cache`:
+        // ningún código de este repo escribe ese path, así que nunca podía
+        // fallar y no aportaba evidencia real de aislamiento.)
+        expect(() => (0, discover_1.discoverProcessModels)()).not.toThrow();
+    });
+    it('usa path.join y no separadores hardcodeados', () => {
+        const src = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../../src/core/process/discover.ts'), 'utf-8');
+        expect(src).not.toMatch(/['"`][^'"`]*\/skills\//);
+        expect(src).toContain('path.join');
+    });
+});