agentic-workflow-manager 9.0.2 → 9.2.0

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');
+    });
+});

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const text_1 = require("../../src/core/text");
+describe('stripControlChars', () => {
+    it('elimina ESC y demas bytes de control C0', () => {
+        expect((0, text_1.stripControlChars)('a\x1b[31mb\x00c\x07d')).toBe('a[31mbcd');
+    });
+    it('preserva \\n y \\t, que son whitespace legitimo', () => {
+        expect((0, text_1.stripControlChars)('a\nb\tc')).toBe('a\nb\tc');
+    });
+    it('elimina DEL (0x7F)', () => {
+        expect((0, text_1.stripControlChars)('a\x7Fb')).toBe('ab');
+    });
+});
+describe('sanitizeDeclaredField', () => {
+    it('quita marcado markdown Y bytes de control en una sola pasada', () => {
+        expect((0, text_1.sanitizeDeclaredField)('a\x1bx')).toBe('ax');
+        expect((0, text_1.sanitizeDeclaredField)('a\n## Forjado *b* `c` <d>')).toBe('a  Forjado b c d');
+    });
+    it('no deja ESC ni otros C0 sobrevivir aunque el saneo markdown no los toque', () => {
+        // eslint-disable-next-line no-control-regex -- verificamos la ausencia deliberada de C0
+        expect((0, text_1.sanitizeDeclaredField)('name\x1b[31mred\x07')).not.toMatch(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/);
+    });
+    it('es idempotente sobre texto ya limpio', () => {
+        const clean = 'a plain name';
+        expect((0, text_1.sanitizeDeclaredField)(clean)).toBe(clean);
+        expect((0, text_1.sanitizeDeclaredField)((0, text_1.sanitizeDeclaredField)(clean))).toBe(clean);
+    });
+});

package/dist/tests/integration/context-orchestrators-e2e.test.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const CLI_ROOT = path_1.default.resolve(__dirname, '../..');
+const DIST = path_1.default.join(CLI_ROOT, 'dist', 'src', 'index.js');
+/** Registry de prueba con un orquestador declarado. Nunca toca el ~/.awm real (R7.4). */
+function seedRegistry() {
+    const home = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-e2e-')));
+    const awmHome = path_1.default.join(home, '.awm');
+    const root = path_1.default.join(awmHome, 'registries', 'test-registry');
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'test-registry', remote: 'https://example.invalid/test.git' }]));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({
+        minCliVersion: '8.5.0',
+        orchestrator: { name: 'ejemplo-proceso', appliesWhen: 'cuando hay una tarea sin plan', terminatesTo: 'development-process' },
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
+    return home;
+}
+/**
+ * Registry con un nombre de orquestador REALISTA: `task_capture_process`, con guion bajo —
+ * la misma clase de caracter (`_`) que disparaba el falso-negativo de `--verify` fijado en
+ * 3e8ce65 (arg crudo vs. nombre saneado). `seedRegistry()` usa un nombre puramente
+ * alfanumerico-con-guiones que nunca ejercito esa clase de caracter a nivel del binario
+ * real — este fixture cierra ese hueco (Finding 1 confirmado del QA post-implementacion) y
+ * ademas es representativo de lo que la generacion de `process-lifecycle` (Task 5)
+ * plausiblemente produce a partir de un `name` tipo slug.
+ */
+function seedRealisticRegistry() {
+    const home = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-e2e-real-')));
+    const awmHome = path_1.default.join(home, '.awm');
+    const root = path_1.default.join(awmHome, 'registries', 'test-registry');
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'test-registry', remote: 'https://example.invalid/test.git' }]));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({
+        minCliVersion: '8.5.0',
+        orchestrator: {
+            name: 'task_capture_process',
+            appliesWhen: 'cuando llega una tarea sin capturar en el backlog',
+            terminatesTo: 'development-process',
+        },
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
+    return home;
+}
+/**
+ * DOS registries en el mismo `AWM_HOME`: uno con declaracion valida ('sana') y otro con una
+ * declaracion rota (le falta `terminatesTo`) que `readDeclaredOrchestrators`
+ * (core/orchestrators.ts) diagnostica sin lanzar (R1.2) — rechaza SOLO esa declaracion,
+ * sin invalidar el registry que la contiene ni a los demas. Ejercita R7.1 a nivel del
+ * binario real: diagnosticos por stderr sin dejar de listar lo sano por stdout
+ * (Finding 2 confirmado del QA post-implementacion, hasta ahora solo unit-testeado en
+ * tests/commands/context.test.ts).
+ */
+function seedMixedRegistries() {
+    const home = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-e2e-mixed-')));
+    const awmHome = path_1.default.join(home, '.awm');
+    const sanoRoot = path_1.default.join(awmHome, 'registries', 'sano-registry');
+    const rotoRoot = path_1.default.join(awmHome, 'registries', 'roto-registry');
+    fs_1.default.mkdirSync(path_1.default.join(sanoRoot, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(rotoRoot, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([
+        { name: 'sano-registry', remote: 'https://example.invalid/sano.git' },
+        { name: 'roto-registry', remote: 'https://example.invalid/roto.git' },
+    ]));
+    fs_1.default.writeFileSync(path_1.default.join(sanoRoot, 'awm-registry.json'), JSON.stringify({
+        minCliVersion: '8.5.0',
+        orchestrator: { name: 'proceso-sano', appliesWhen: 'cuando hay una tarea sin plan', terminatesTo: 'development-process' },
+    }));
+    // Declaracion rota: falta "terminatesTo" -- readDeclaredOrchestrators la rechaza y
+    // reporta un diagnostico en vez de lanzar o componerla silenciosamente (R1.2).
+    fs_1.default.writeFileSync(path_1.default.join(rotoRoot, 'awm-registry.json'), JSON.stringify({
+        minCliVersion: '8.5.0',
+        orchestrator: { name: 'proceso-roto', appliesWhen: 'cuando algo pasa' },
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(sanoRoot, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
+    fs_1.default.writeFileSync(path_1.default.join(rotoRoot, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
+    return home;
+}
+function run(home, ...args) {
+    return (0, child_process_1.spawnSync)(process.execPath, [DIST, ...args], {
+        cwd: CLI_ROOT, encoding: 'utf8',
+        env: { ...process.env, HOME: home, AWM_HOME: path_1.default.join(home, '.awm'), AWM_NO_UPDATE_CHECK: '1' },
+    });
+}
+describe('awm context orchestrators (binario real)', () => {
+    let home;
+    beforeAll(() => { home = seedRegistry(); });
+    afterAll(() => fs_1.default.rmSync(home, { recursive: true, force: true }));
+    it('reporta el orquestador declarado por el registry sembrado', () => {
+        const r = run(home, 'context', 'orchestrators');
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('ejemplo-proceso');
+    });
+    it('--json emite la lista parseable', () => {
+        const r = run(home, 'context', 'orchestrators', '--json');
+        expect(r.status).toBe(0);
+        expect(JSON.parse(r.stdout).orchestrators[0].name).toBe('ejemplo-proceso');
+    });
+    it('--verify cierra el ciclo de verificacion con exit code', () => {
+        expect(run(home, 'context', 'orchestrators', '--verify', 'ejemplo-proceso').status).toBe(0);
+        const ausente = run(home, 'context', 'orchestrators', '--verify', 'no-existe');
+        expect(ausente.status).toBe(2);
+        expect(ausente.stderr).toContain('ejemplo-proceso');
+    });
+});
+describe('awm context orchestrators -- nombre realista con guion bajo (binario real)', () => {
+    let home;
+    beforeAll(() => { home = seedRealisticRegistry(); });
+    afterAll(() => fs_1.default.rmSync(home, { recursive: true, force: true }));
+    it('--verify con el nombre RAW declarado (con guion bajo) compone -- regression del fix 3e8ce65', () => {
+        const r = run(home, 'context', 'orchestrators', '--verify', 'task_capture_process');
+        expect(r.status).toBe(0);
+        expect(r.stdout).toMatch(/composed/i);
+    });
+    it('la lista en texto plano y --json muestran el nombre saneado (guion bajo removido)', () => {
+        const plano = run(home, 'context', 'orchestrators');
+        expect(plano.status).toBe(0);
+        expect(plano.stdout).toContain('taskcaptureprocess');
+        expect(plano.stdout).not.toContain('task_capture_process');
+        const json = run(home, 'context', 'orchestrators', '--json');
+        expect(json.status).toBe(0);
+        expect(JSON.parse(json.stdout).orchestrators[0].name).toBe('taskcaptureprocess');
+    });
+});
+describe('awm context orchestrators -- diagnosticos + sanos mezclados (binario real)', () => {
+    let home;
+    beforeAll(() => { home = seedMixedRegistries(); });
+    afterAll(() => fs_1.default.rmSync(home, { recursive: true, force: true }));
+    it('lista el orquestador sano por stdout y diagnostica el roto por stderr sin fallar', () => {
+        const r = run(home, 'context', 'orchestrators');
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('proceso-sano');
+        expect(r.stderr).toContain('warning:');
+        expect(r.stderr).toContain('roto-registry');
+        expect(r.stderr).toContain('terminatesTo');
+    });
+});

package/dist/tests/integration/process-model-e2e.test.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/integration/process-model-e2e.test.ts
+//
+// Ledger signature: ca1-2-1-3-no-e2e-regression-test.
+//
+// CA-1.2 y CA-1.3 del plan R1a (docs/plans/2026-08-23-process-model-r1a-plan.md)
+// fueron verificados MANUALMENTE varias veces durante esa sesión, pero ningún
+// test permanente los sostenía. Este test cierra ese hueco ejecutando el
+// binario compilado real (dist/src/index.js) contra un AWM_HOME/registry
+// fixture aislado — no llama funciones internas directamente. El plan es
+// explícito: "No vale el test unitario: el criterio dice 'reporta', y eso se
+// prueba ejecutando" (CA-1.2). Sigue el patrón de invocación de
+// tests/structural/r3-cli-major-version.test.ts (spawnSync del dist compilado)
+// y el patrón de fixture de tests/core/process/discover.test.ts +
+// tests/core/process/no-regression.test.ts (registries.json + skills/<name>/SKILL.md
+// bajo un AWM_HOME de tmpdir, nunca el ~/.awm real).
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const CLI_ROOT = path_1.default.resolve(__dirname, '../..');
+const DIST_ENTRYPOINT = path_1.default.join(CLI_ROOT, 'dist', 'src', 'index.js');
+// Fixture canónico del plan R1a, reproducido byte a byte (bloque "Canonical fixture").
+const EJEMPLO_PROCESO_SKILL_MD = `---
+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
+
+## 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
+
+Nada.
+`;
+/** Construye AWM_HOME/registries.json + AWM_HOME/registries/<name>/skills/<skill>/SKILL.md
+ *  — el mismo layout que contentRoots() (src/core/registries.ts) resuelve para
+ *  descubrimiento real, sin clonar git: contentRoots() solo necesita que el
+ *  directorio exista y pase inspectRegistrySafety (ningún symlink, ≥1 dir
+ *  administrado). El campo "remote" no se usa en este test — nada corre `awm update`. */
+function fixture() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-process-e2e-'));
+    const project = path_1.default.join(root, 'project');
+    const home = path_1.default.join(root, 'home');
+    const awmHome = path_1.default.join(home, '.awm');
+    const registryRoot = path_1.default.join(awmHome, 'registries', 'baseline');
+    fs_1.default.mkdirSync(project, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills', 'ejemplo-proceso'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(project, 'package.json'), JSON.stringify({ name: 'process-model-e2e-fixture', private: true }));
+    fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.invalid/baseline.git' }]));
+    fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills', 'ejemplo-proceso', 'SKILL.md'), EJEMPLO_PROCESO_SKILL_MD);
+    return { root, project, home, awmHome };
+}
+function runCompiledCli(f, ...args) {
+    const result = (0, child_process_1.spawnSync)(process.execPath, [DIST_ENTRYPOINT, ...args], {
+        cwd: f.project,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: f.home,
+            USERPROFILE: f.home,
+            AWM_HOME: f.awmHome,
+            AWM_NO_UPDATE_CHECK: '1',
+        },
+    });
+    expect(result.error).toBeUndefined();
+    return { code: result.status, stdout: result.stdout, stderr: result.stderr };
+}
+describe('process model E2E against the real built binary (CA-1.2, CA-1.3)', () => {
+    jest.setTimeout(60_000);
+    beforeAll(() => {
+        if (!fs_1.default.existsSync(DIST_ENTRYPOINT)) {
+            throw new Error(`${DIST_ENTRYPOINT} no existe — este test ejecuta el binario compilado real. ` +
+                'Correr `npm run build` antes de `jest` (mismo pre-requisito que tests/structural/r3-cli-major-version.test.ts).');
+        }
+    });
+    let f;
+    beforeEach(() => { f = fixture(); });
+    afterEach(() => { fs_1.default.rmSync(f.root, { recursive: true, force: true }); });
+    test('CA-1.2 — `process list` reporta ejemplo-proceso con su status', () => {
+        const result = runCompiledCli(f, 'process', 'list');
+        expect(result.code).toBe(0);
+        expect(result.stdout).toContain('ejemplo-proceso');
+        expect(result.stdout).toContain('draft');
+    });
+    test('CA-1.2 — `process show ejemplo-proceso --json` emite el modelo parseado completo', () => {
+        const result = runCompiledCli(f, 'process', 'show', 'ejemplo-proceso', '--json');
+        expect(result.code).toBe(0);
+        const model = JSON.parse(result.stdout);
+        expect(model).toEqual(expect.objectContaining({
+            name: 'ejemplo-proceso',
+            schema: 1,
+            status: 'draft',
+            entryPoint: true,
+            terminatesTo: 'none',
+        }));
+        expect(model.body.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' },
+                ] },
+        ]);
+        expect(model.body.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' },
+        ]);
+        expect(model.body.termination).toBe('finishing-a-development-branch');
+        // No source path leaks into the published/consumable view (see publicView
+        // in src/commands/process/index.ts) — assert the field is entirely absent.
+        expect(model).not.toHaveProperty('source');
+    });
+    test('CA-1.3 — `doctor --full` renderiza la seccion Processes desde el adapter, sin re-parseo ad-hoc', () => {
+        const result = runCompiledCli(f, 'doctor', '--full');
+        expect([0, 1]).toContain(result.code);
+        expect(result.stdout).toContain('Processes');
+        // El adapter de producción (productionDashboardAdapters.processes, src/core/dashboard/collect.ts)
+        // construye el id de item como `process.<name>` vía sanitizeDashboardId — esto es lo que
+        // demuestra que la sección viene del adapter real (discoverProcessModels() -> Dashboard),
+        // no de un parser propio del Dashboard.
+        expect(result.stdout).toContain('process.ejemplo-proceso');
+    });
+});