agentic-workflow-manager 9.0.2 → 9.1.0

package/dist/tests/commands/ledger/index.test.js

@@ -51,6 +51,17 @@ describe('awm ledger CLI', () => {
             .toThrow(/defect-class.*kebab-case/i);
         expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([]);
     });
+    test.each(['test', 'Test', 'test-check', 'test_x', 'placeholder', 'foo', 'bar', 'todo', 'tbd'])('add rejects a placeholder --desc %p before writing', (desc) => {
+        expect(() => run(['add', '--branch', 'feat-x', '--polarity', 'finding', '--class', 'logica',
+            '--signature', 'sig-1', '--severity', 'blocker', '--desc', desc], cwd))
+            .toThrow(/placeholder.*ledger add --help/i);
+        expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([]);
+    });
+    test('add accepts a real description that merely contains the word test', () => {
+        run(['add', '--branch', 'feat-x', '--polarity', 'finding', '--class', 'logica',
+            '--signature', 'sig-1', '--severity', 'blocker', '--desc', 'unit test for parseConfig throws on empty input'], cwd);
+        expect((0, store_1.listEntries)(cwd, 'feat-x')).toHaveLength(1);
+    });
     test('list emits the branch entries as JSON', () => {
         run(['add', '--branch', 'feat-x', '--polarity', 'win', '--class', 'proceso',
             '--signature', 'good', '--severity', 'info', '--desc', 'nice'], cwd);

package/dist/tests/commands/process.test.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/commands/process.test.ts
+const process_1 = require("../../src/commands/process");
+function model(over = {}) {
+    return {
+        schema: 1, name: 'mi-proceso', status: 'draft', entryPoint: true, terminatesTo: 'none',
+        created: '2026-08-23', updated: '2026-08-23', source: '/r/skills/mi-proceso/SKILL.md',
+        body: {
+            objective: 'G — Objetivo.', appliesWhen: 'Siempre.',
+            structure: [{ id: 'SG-1', text: 'Uno', operations: [{ id: 'OP-1.1', text: 'Hacer' }] }],
+            routing: [{ when: 'Al empezar', requiredState: '', goesTo: 'OP-1.1', endsAt: 'SG-1' }],
+            termination: 'none', unverified: ['Nada.'],
+        },
+        ...over,
+    };
+}
+describe('awm process list', () => {
+    it('reporta los procesos descubiertos', () => {
+        const r = (0, process_1.runProcessList)({ models: [model()], diagnostics: [] });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toContain('mi-proceso');
+        expect(r.stdout).toContain('draft');
+    });
+    it('sin modelos sale 0 y lo dice, no falla', () => {
+        const r = (0, process_1.runProcessList)({ models: [], diagnostics: [] });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toMatch(/no process models/i);
+    });
+    it('emite los diagnósticos sin dejar de listar los sanos', () => {
+        const r = (0, process_1.runProcessList)({ models: [model()], diagnostics: ['/r/x: invalid process model — boom'] });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toContain('mi-proceso');
+        expect(r.stderr).toContain('boom');
+    });
+});
+describe('awm process show --json', () => {
+    it('emite el modelo parseado como JSON', () => {
+        const r = (0, process_1.runProcessShow)({ models: [model()], diagnostics: [] }, 'mi-proceso', true);
+        expect(r.code).toBe(0);
+        const parsed = JSON.parse(r.stdout);
+        expect(parsed).toEqual(expect.objectContaining({ name: 'mi-proceso', schema: 1, status: 'draft' }));
+        expect(parsed.body.routing).toEqual([{ when: 'Al empezar', requiredState: '', goesTo: 'OP-1.1', endsAt: 'SG-1' }]);
+    });
+    it('el JSON no filtra el path del filesystem del registry', () => {
+        const parsed = JSON.parse((0, process_1.runProcessShow)({ models: [model()], diagnostics: [] }, 'mi-proceso', true).stdout);
+        expect(JSON.stringify(parsed)).not.toContain('/r/skills');
+    });
+    it('un nombre inexistente sale 2 y nombra lo disponible', () => {
+        const r = (0, process_1.runProcessShow)({ models: [model()], diagnostics: [] }, 'no-existe', true);
+        expect(r.code).toBe(2);
+        expect(r.stderr).toMatch(/no-existe/);
+    });
+});
+describe('awm process show (texto)', () => {
+    it('renderiza name/status/objective/structure en modo texto', () => {
+        const r = (0, process_1.runProcessShow)({ models: [model()], diagnostics: [] }, 'mi-proceso', false);
+        expect(r.code).toBe(0);
+        expect(r.stdout).toContain('mi-proceso (draft)');
+        expect(r.stdout).toContain('G — Objetivo.');
+        expect(r.stdout).toContain('SG-1 — Uno');
+        expect(r.stdout).toContain('OP-1.1 — Hacer');
+    });
+    it('un nombre inexistente en modo texto sale 2 y nombra lo disponible', () => {
+        const r = (0, process_1.runProcessShow)({ models: [model()], diagnostics: [] }, 'no-existe', false);
+        expect(r.code).toBe(2);
+        expect(r.stderr).toMatch(/no-existe/);
+        expect(r.stdout).toBe('');
+    });
+    it('sanea bytes de control/ANSI del body antes de escribir a stdout', () => {
+        const hostile = model({
+            body: {
+                objective: 'G — Objetivo\x1b[31mmalicioso\x1b[0m.',
+                appliesWhen: 'Siempre.',
+                structure: [{ id: 'SG-1', text: 'Uno\x1b]0;pwned\x07', operations: [{ id: 'OP-1.1', text: 'Hacer\x1b[2Jcosas' }] }],
+                routing: [{ when: 'Al empezar', requiredState: '', goesTo: 'OP-1.1', endsAt: 'SG-1' }],
+                termination: 'none', unverified: ['Nada.'],
+            },
+        });
+        const r = (0, process_1.runProcessShow)({ models: [hostile], diagnostics: [] }, 'mi-proceso', false);
+        expect(r.code).toBe(0);
+        // eslint-disable-next-line no-control-regex -- necesitamos verificar la ausencia deliberada de C0
+        expect(r.stdout).not.toMatch(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/);
+        expect(r.stdout).toContain('Objetivo[31mmalicioso[0m.');
+        expect(r.stdout).toContain('Uno]0;pwned');
+        expect(r.stdout).toContain('Hacer[2Jcosas');
+    });
+});

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