agentic-workflow-manager 9.0.2 → 9.2.0

package/dist/tests/core/dashboard/collect.test.js

@@ -21,9 +21,10 @@ describe('collectDashboardSnapshot', () => {
         const project = jest.fn();
         const plans = jest.fn();
         const execution = jest.fn();
+        const processes = jest.fn();
         const snapshot = (0, collect_1.collectDashboardSnapshot)({
             cwd: '/definitely-not-a-project', now: fixedNow,
-            adapters: { machine: () => ({ findings: [] }), project, plans, execution },
+            adapters: { machine: () => ({ findings: [] }), project, plans, execution, processes },
         });
         expect(snapshot.project).toEqual({ detected: false, label: 'No project detected' });
         expect(snapshot.sections.map((section) => section.id)).toEqual(['machine']);
@@ -31,14 +32,15 @@ describe('collectDashboardSnapshot', () => {
         expect(project).not.toHaveBeenCalled();
         expect(plans).not.toHaveBeenCalled();
         expect(execution).not.toHaveBeenCalled();
+        expect(processes).not.toHaveBeenCalled();
     });
     it('fails loudly for malformed central machine findings', () => {
-        expect(() => (0, collect_1.collectDashboardSnapshot)({ cwd: '/definitely-not-a-project', now: fixedNow, adapters: { machine: () => ({ findings: [{ id: '', label: 'Preferences', state: 'ok' }] }), project: jest.fn(), plans: jest.fn(), execution: jest.fn() } })).toThrow(/finding/i);
+        expect(() => (0, collect_1.collectDashboardSnapshot)({ cwd: '/definitely-not-a-project', now: fixedNow, adapters: { machine: () => ({ findings: [{ id: '', label: 'Preferences', state: 'ok' }] }), project: jest.fn(), plans: jest.fn(), execution: jest.fn(), processes: jest.fn() } })).toThrow(/finding/i);
     });
     it.each([undefined, null, {}, 'healthy'])('rejects a non-array central machine findings value: %p', (findings) => {
         expect(() => (0, collect_1.collectDashboardSnapshot)({
             cwd: '/definitely-not-a-project', now: fixedNow,
-            adapters: { machine: () => ({ findings }), project: jest.fn(), plans: jest.fn(), execution: jest.fn() },
+            adapters: { machine: () => ({ findings }), project: jest.fn(), plans: jest.fn(), execution: jest.fn(), processes: jest.fn() },
         })).toThrow('Dashboard findings must be an array');
     });
     it('uses exact verified remediation commands and stable ordered sections', () => {
@@ -49,6 +51,7 @@ describe('collectDashboardSnapshot', () => {
                 project: () => ({ label: 'Demo', findings: [{ id: 'project.profile.missing', label: 'Profile', state: 'missing' }] }),
                 plans: () => Array.from({ length: 2000 }, (_, index) => ({ id: `plan.${index}`, label: `Plan ${index}`, state: 'ok' })),
                 execution: () => ({}),
+                processes: () => [],
             },
         });
         expect(snapshot.sections.map((section) => section.id)).toEqual(// verifies R6.3
@@ -59,11 +62,11 @@ describe('collectDashboardSnapshot', () => {
         expect(JSON.stringify(snapshot)).not.toMatch(/score|ranking/i);
     });
     it('el snapshot declara schema 2', () => {
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         expect(snapshot.schema).toBe(2);
     });
-    it('processes queda declarada no aplicable hasta R1', () => {
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+    it('processes queda no aplicable cuando el adapter no declara modelos', () => {
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         const processes = snapshot.sections.find((section) => section.id === 'processes');
         expect(processes).toEqual({ id: 'processes', availability: 'not_applicable', items: [] });
     });
@@ -73,7 +76,7 @@ describe('collectDashboardSnapshot', () => {
             adapters: {
                 machine: () => ({ findings: [{ id: 'unknown', label: 'Unknown', state: 'missing' }] }),
                 project: () => { throw new Error('corrupt project source'); },
-                plans: () => [], execution: () => undefined,
+                plans: () => [], execution: () => undefined, processes: () => [],
             },
         });
         expect(snapshot.sections.find((section) => section.id === 'machine')?.items).toEqual([]);
@@ -83,7 +86,7 @@ describe('collectDashboardSnapshot', () => {
     it('marks execution-derived sections unavailable when no read-only execution source exists', () => {
         const snapshot = (0, collect_1.collectDashboardSnapshot)({
             cwd: process.cwd(), now: fixedNow,
-            adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined },
+            adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] },
         });
         for (const id of ['execution', 'qa', 'docs', 'retro']) {
             expect(snapshot.sections.find((section) => section.id === id)?.availability).toBe('unavailable');
@@ -92,29 +95,29 @@ describe('collectDashboardSnapshot', () => {
     it('isolates malformed optional source data to its owning section', () => {
         const snapshot = (0, collect_1.collectDashboardSnapshot)({
             cwd: process.cwd(), now: fixedNow,
-            adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [{ id: 'bad', label: 'Profile', state: 'invented' }] }), plans: () => [], execution: () => undefined },
+            adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [{ id: 'bad', label: 'Profile', state: 'invented' }] }), plans: () => [], execution: () => undefined, processes: () => [] },
         });
         expect(snapshot.sections.find((section) => section.id === 'project')?.availability).toBe('unavailable');
         expect(snapshot.sections.find((section) => section.id === 'machine')?.availability).toBe('available');
     });
     it('isolates malformed post-sanitization plan findings', () => {
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [{ id: '', label: 'Profile', state: 'ok' }], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [{ id: '', label: 'Profile', state: 'ok' }], execution: () => undefined, processes: () => [] } });
         expect(snapshot.sections.find((section) => section.id === 'planning')?.availability).toBe('unavailable');
     });
     it('isolates malformed project findings without dropping other sections', () => {
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [{ id: '', label: 'Profile', state: 'ok' }] }), plans: () => [], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [{ id: '', label: 'Profile', state: 'ok' }] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         expect(snapshot.sections.find((section) => section.id === 'project')?.availability).toBe('unavailable');
         expect(snapshot.sections.find((section) => section.id === 'planning')?.availability).toBe('available');
     });
     it.each(['execution', 'qa', 'docs', 'retro'])('isolates malformed %s findings', (key) => {
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => ({ [key]: [{ id: '', label: 'Profile', state: 'ok' }] }) } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => ({ [key]: [{ id: '', label: 'Profile', state: 'ok' }] }), processes: () => [] } });
         expect(snapshot.sections.find((section) => section.id === key)?.availability).toBe('unavailable');
     });
     it('renders exact remediation only for a canonical optional source failure', () => {
         const knownFailure = Object.assign(new Error('sensors unavailable'), { findingId: 'project.sensors.unavailable', remediationVerified: true });
         const snapshot = (0, collect_1.collectDashboardSnapshot)({
             cwd: process.cwd(), now: fixedNow,
-            adapters: { machine: () => ({ findings: [] }), project: () => { throw knownFailure; }, plans: () => [], execution: () => undefined },
+            adapters: { machine: () => ({ findings: [] }), project: () => { throw knownFailure; }, plans: () => [], execution: () => undefined, processes: () => [] },
         });
         expect(snapshot.sections.find((section) => section.id === 'project')?.items).toEqual([
             expect.objectContaining({ id: 'project.sensors.unavailable', state: 'unavailable', remediation: 'awm sensors status' }),
@@ -133,6 +136,7 @@ describe('collectDashboardSnapshot', () => {
                     throw failure; return []; },
                 execution: () => { if (adapter === 'execution')
                     throw failure; return undefined; },
+                processes: () => [],
             },
         });
         expect(snapshot.sections.find((section) => section.id === sectionId)?.items[0]).toEqual(expect.objectContaining({ id: findingId, remediation }));
@@ -143,7 +147,7 @@ describe('collectDashboardSnapshot', () => {
             adapters: { machine: () => ({ findings: [
                         { id: 'machine.registries.stale', label: 'Registries', state: 'attention' },
                         { id: 'machine.preferences.missing', label: 'Preferences', state: 'missing' },
-                    ] }), project: jest.fn(), plans: jest.fn(), execution: jest.fn() },
+                    ] }), project: jest.fn(), plans: jest.fn(), execution: jest.fn(), processes: jest.fn() },
         });
         expect(snapshot.sections[0].items.map((item) => item.id)).toEqual(['machine.preferences.missing', 'machine.registries.stale']);
     });
@@ -154,13 +158,13 @@ describe('collectDashboardSnapshot', () => {
                     : expected === 'retro_pending' ? { markers: { qaComplete: true, docsComplete: true, retroComplete: false }, tasks: { total: 1, completed: 1 } }
                         : expected === 'qa_pending' ? { markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total: 1, completed: 1 } }
                             : { markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total: 0, completed: 0 } };
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [{ id: 'plan.lifecycle', label: 'Profile', state: 'ok', lifecycle }], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [{ id: 'plan.lifecycle', label: 'Profile', state: 'ok', lifecycle }], execution: () => undefined, processes: () => [] } });
         expect(snapshot.sections.find((section) => section.id === 'planning')?.items[0].detail).toBe(expected);
     });
     it('degrades a machine-only dashboard for actionable machine findings', () => {
         const snapshot = (0, collect_1.collectDashboardSnapshot)({
             cwd: '/definitely-not-a-project', now: fixedNow,
-            adapters: { machine: () => ({ findings: [{ id: 'machine.preferences.missing', label: 'Preferences', state: 'missing' }] }), project: jest.fn(), plans: jest.fn(), execution: jest.fn() },
+            adapters: { machine: () => ({ findings: [{ id: 'machine.preferences.missing', label: 'Preferences', state: 'missing' }] }), project: jest.fn(), plans: jest.fn(), execution: jest.fn(), processes: jest.fn() },
         });
         expect(snapshot.sections.map((section) => section.id)).toEqual(['machine']);
         expect(snapshot.overall).toBe('degraded');
@@ -169,7 +173,7 @@ describe('collectDashboardSnapshot', () => {
         const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-dashboard-'));
         fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
         (0, store_1.writeCycleEvidence)(root, (0, evidence_fixtures_1.cycleEvidenceFixture)());
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         const history = snapshot.sections.find((section) => section.id === 'history');
         expect(snapshot.confidence).toBe('provisional');
         expect(history?.availability).toBe('available');
@@ -180,7 +184,7 @@ describe('collectDashboardSnapshot', () => {
         const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-dashboard-'));
         fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
         (0, store_1.writeCycleEvidence)(root, { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleState: 'blocked', plan: { ref: 'docs/plans/current.md', state: 'blocked' } });
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         expect(snapshot.sections.find((section) => section.id === 'history')?.items).toEqual([
             expect.objectContaining({ state: 'attention', remediation: 'awm preflight' }),
         ]);
@@ -203,7 +207,7 @@ describe('collectDashboardSnapshot', () => {
             fs_1.default.mkdirSync(path_1.default.join(root, '.awm', 'evidence'), { recursive: true });
             fs_1.default.symlinkSync(external, path_1.default.join(root, '.awm', 'evidence', 'cycles'));
         }
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         const history = snapshot.sections.find((section) => section.id === 'history');
         expect(history).toEqual(expect.objectContaining({ availability: 'unavailable', items: [] }));
         fs_1.default.rmSync(root, { recursive: true, force: true });
@@ -219,7 +223,7 @@ describe('collectDashboardSnapshot', () => {
         const directory = path_1.default.join(root, '.awm', 'evidence', 'cycles');
         fs_1.default.mkdirSync(directory, { recursive: true });
         fs_1.default.symlinkSync(externalFile, path_1.default.join(directory, `${cycleId}.json`));
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         expect(snapshot.sections.find((section) => section.id === 'history')).toEqual(expect.objectContaining({ availability: 'unavailable', items: [] }));
         fs_1.default.rmSync(root, { recursive: true, force: true });
         fs_1.default.rmSync(external, { recursive: true, force: true });
@@ -232,7 +236,7 @@ describe('collectDashboardSnapshot', () => {
         const record = (0, evidence_fixtures_1.cycleEvidenceFixture)();
         const filename = caseName === 'duplicate' ? `${'b'.repeat(64)}.json` : `${'b'.repeat(64)}.json`;
         fs_1.default.writeFileSync(path_1.default.join(directory, filename), JSON.stringify(caseName === 'duplicate' ? record : { ...record, cycleId: 'c'.repeat(64) }));
-        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [] } });
         expect(snapshot.sections.find((section) => section.id === 'history')).toEqual(expect.objectContaining({ availability: 'unavailable', items: [] }));
         fs_1.default.rmSync(root, { recursive: true, force: true });
     });

package/dist/tests/core/dashboard/processes-section.test.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collect_1 = require("../../../src/core/dashboard/collect");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function adapters(processes) {
+    return { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes };
+}
+describe('sección processes del Dashboard', () => {
+    let root;
+    beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-processes-section-')); fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}'); });
+    afterEach(() => { fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    function snapshot(a) {
+        return (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: '2026-08-23T00:00:00.000Z', adapters: a });
+    }
+    function section(a) {
+        return snapshot(a).sections.find((s) => s.id === 'processes');
+    }
+    it('puebla la sección desde el adapter', () => {
+        const s = section(adapters(() => [{ name: 'mi-proceso', status: 'active' }]));
+        expect(s.availability).toBe('available');
+        expect(s.items).toEqual([expect.objectContaining({ id: 'process.mi-proceso', label: 'Process', state: 'ok', detail: 'active' })]);
+    });
+    it('un draft se reporta como attention, no como ok', () => {
+        expect(section(adapters(() => [{ name: 'x', status: 'draft' }])).items[0]).toEqual(expect.objectContaining({ state: 'attention', detail: 'draft' }));
+    });
+    it('un draft trae remediation "awm process list" y degrada el overall del snapshot', () => {
+        const snap = snapshot(adapters(() => [{ name: 'x', status: 'draft' }]));
+        const s = snap.sections.find((sec) => sec.id === 'processes');
+        expect(s.items[0]).toEqual(expect.objectContaining({ state: 'attention', detail: 'draft', remediation: 'awm process list' }));
+        expect(snap.overall).toBe('degraded');
+    });
+    it('sin procesos la sección queda not_applicable, como antes de R1a', () => {
+        expect(section(adapters(() => []))).toEqual(expect.objectContaining({ availability: 'not_applicable', items: [] }));
+    });
+    it('un adapter que lanza degrada a unavailable sin tumbar el snapshot', () => {
+        const s = section(adapters(() => { throw new Error('/home/u/secreto boom'); }));
+        expect(s.availability).toBe('unavailable');
+        expect(JSON.stringify(s)).not.toContain('secreto');
+    });
+    it('un registry externo no puede inyectar markup ni rutas por el nombre', () => {
+        // El nombre ya fue validado como slug por el contrato (Task 1). Este test
+        // prueba la SEGUNDA barrera: aunque un adapter mal escrito dejara pasar
+        // algo hostil, el sanitizador lo neutraliza antes del render.
+        const s = section(adapters(() => [{ name: '<script>/etc/passwd', status: 'active' }]));
+        const serialized = JSON.stringify(s);
+        expect(serialized).not.toContain('<script>');
+        expect(serialized).not.toContain('/etc/passwd');
+    });
+    it('un nombre con forma de slug inválida no produce un id process.<bad-name>', () => {
+        // 'mi proceso' (con espacio) no matchea DANGEROUS (no es un path, token,
+        // secreto ni markup), así que sanitizeDashboardSource lo deja pasar tal
+        // cual sobre el source crudo. La SEGUNDA barrera tiene que actuar sobre
+        // el id ya construido (`process.mi proceso`), no sobre el nombre crudo:
+        // PROCESS_FINDING_ID no matchea ese id, así que debe caer al fallback
+        // hasheado `item-<hash>` — igual que cualquier otro id malformado — y
+        // nunca renderizarse como `process.mi proceso`.
+        const s = section(adapters(() => [{ name: 'mi proceso', status: 'active' }]));
+        expect(s.items).toHaveLength(1);
+        const item = s.items[0];
+        expect(item.id).toMatch(/^item-[0-9a-f]{16}$/);
+        expect(item.id).not.toContain('process.mi proceso');
+        expect(item.label).toBe('Process');
+        expect(item.state).toBe('ok');
+        expect(item.detail).toBe('active');
+    });
+});

package/dist/tests/core/dashboard/production-adapters.test.js

@@ -12,6 +12,44 @@ const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const PROCESS_MODEL_FIXTURE = `---
+awm: process-model
+schema: 1
+name: NAME
+status: STATUS
+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 context() {
     return {
         machine: {},
@@ -174,4 +212,24 @@ describe('productionDashboardAdapters', () => {
         expect(JSON.stringify(snapshot)).not.toMatch(/dashboard-journal-only|dashboard@example|Dashboard Test/i);
         fs_1.default.rmSync(root, { recursive: true, force: true });
     });
+    it('processes delegates to discoverProcessModels() and maps its models to {name, status}', () => {
+        const awmHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-dashboard-processes-home-'));
+        const originalAwmHome = process.env.AWM_HOME;
+        process.env.AWM_HOME = awmHome;
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.test/baseline.git' }]));
+            const skillDir = path_1.default.join(awmHome, 'registries', 'baseline', 'skills', 'mi-proceso');
+            fs_1.default.mkdirSync(skillDir, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(skillDir, 'SKILL.md'), PROCESS_MODEL_FIXTURE.replace('NAME', 'mi-proceso').replace('STATUS', 'active'));
+            const adapters = (0, collect_1.productionDashboardAdapters)(context());
+            expect(adapters.processes({ root: '/private/project' })).toEqual([{ name: 'mi-proceso', status: 'active' }]);
+        }
+        finally {
+            if (originalAwmHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = originalAwmHome;
+            fs_1.default.rmSync(awmHome, { recursive: true, force: true });
+        }
+    });
 });

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

@@ -217,6 +217,44 @@ describe('collectDeclaredOrchestrators', () => {
         expect(diagnostics[0]).toMatch(/shared/);
         expect(diagnostics[0]).toMatch(/duplicate|shadow/i);
     });
+    it('sanea el nombre antes de interpolarlo en el diagnostico de duplicado', () => {
+        (0, registries_1.writeRegistriesConfig)([
+            { name: 'first', remote: 'unused' },
+            { name: 'second', remote: 'unused' },
+        ]);
+        const nombreHostil = 'shared\x1b[31m';
+        writeManifest('first', {
+            orchestrator: { name: nombreHostil, appliesWhen: 'primero', terminatesTo: 'a' },
+        });
+        writeManifest('second', {
+            orchestrator: { name: nombreHostil, appliesWhen: 'segundo', terminatesTo: 'b' },
+        });
+        const { diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(diagnostics).toHaveLength(1);
+        // eslint-disable-next-line no-control-regex -- verificamos la ausencia deliberada de C0
+        expect(diagnostics[0]).not.toMatch(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/);
+        expect(diagnostics[0]).toContain('shared[31m');
+    });
+    it('emite un diagnostico de colision post-saneo entre nombres crudos distintos, sin descartar ninguno', () => {
+        (0, registries_1.writeRegistriesConfig)([
+            { name: 'first', remote: 'unused' },
+            { name: 'second', remote: 'unused' },
+        ]);
+        writeManifest('first', {
+            orchestrator: { name: 'foo_bar', appliesWhen: 'x', terminatesTo: 'a' },
+        });
+        writeManifest('second', {
+            orchestrator: { name: 'foo*bar', appliesWhen: 'y', terminatesTo: 'b' },
+        });
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        // Ambas declaraciones son genuinamente distintas (nombre crudo distinto) — ninguna se descarta.
+        expect(declared).toHaveLength(2);
+        expect(declared.map((d) => d.name).sort()).toEqual(['foo*bar', 'foo_bar']);
+        // Pero se advierte de la colision post-saneo (ambas renderizan como "foobar").
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/foobar/);
+        expect(diagnostics[0]).toMatch(/collis|same composed name/i);
+    });
     it('no dedupea orquestadores con nombres distintos, ambos se conservan', () => {
         (0, registries_1.writeRegistriesConfig)([
             { name: 'first', remote: 'unused' },

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