agentic-workflow-manager 9.0.1 → 9.1.0

package/dist/src/commands/ledger/index.js

@@ -6,6 +6,15 @@ const types_1 = require("../../core/ledger/types");
 function archiveLabel() {
     return new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, '');
 }
+// R1a's own retro: across this session, reviewer subagents repeatedly verified
+// this command's flags by issuing a live `ledger add` with a placeholder
+// --desc ("test", "test-check", "test-x", ...) instead of reading --help,
+// polluting the real branch ledger at least six separate times despite
+// explicit prompt instructions not to. --help already documents every flag —
+// the missing piece was a structural backstop, since prompt text alone kept
+// failing to prevent it. This denylist catches the exact placeholder shapes
+// observed; it is not a general anti-test-data filter.
+const PLACEHOLDER_DESC = /^(test|test[-_]?\w{0,10}|placeholder|foo|bar|example|todo|tbd)$/i;
 function registerLedgerCommand(program) {
     const ledger = program.command('ledger').description('persistent per-branch findings ledger (working memory for harness-retro)');
     ledger
@@ -25,6 +34,10 @@ function registerLedgerCommand(program) {
         if (opts.defectClass !== undefined && !types_1.DEFECT_CLASS.test(opts.defectClass)) {
             throw new Error('--defect-class requires a lowercase kebab-case value');
         }
+        if (PLACEHOLDER_DESC.test(opts.desc.trim())) {
+            throw new Error(`--desc "${opts.desc}" looks like a placeholder, not a real finding — ` +
+                'run "awm ledger add --help" to check flag syntax instead of a live add.');
+        }
         const cwd = process.cwd();
         const branch = opts.branch ?? (0, store_1.detectBranch)(cwd);
         const entry = {

package/dist/src/commands/process/index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcessList = runProcessList;
+exports.runProcessShow = runProcessShow;
+exports.registerProcessCommand = registerProcessCommand;
+const discover_1 = require("../../core/process/discover");
+/** `source` es un path absoluto del filesystem local: identifica la máquina, no
+ *  el proceso. Se usa internamente para diagnósticos, y se omite de toda salida
+ *  destinada a ser compartida o consumida por otro programa. */
+function publicView(model) {
+    const { source: _source, ...rest } = model;
+    return rest;
+}
+/** Formatea los diagnósticos de descubrimiento como líneas `warning: ...\n`
+ *  listas para stderr. Compartido por list y show para no divergir el formato. */
+function diagnosticsToStderr(diagnostics) {
+    return diagnostics.map((d) => `warning: ${d}\n`).join('');
+}
+/** Neutraliza bytes de control C0 (incluyendo ESC `\x1b`) de texto de body
+ *  proveniente de un registry no confiable antes de escribirlo a una terminal
+ *  humana. `\n` y `\t` se preservan porque son whitespace legítimo usado por
+ *  la vista de texto; el resto de la vista JSON no pasa por acá — `JSON.stringify`
+ *  ya escapa los caracteres de control como parte de producir JSON válido. Esto
+ *  es un problema distinto y más simple que `sanitizeDashboardSource` (Dashboard,
+ *  Task 5): ahí se canonicaliza ids/labels contra un vocabulario permitido; acá
+ *  solo se neutraliza ANSI/control crudo antes de escribir a stdout. */
+function stripControlChars(text) {
+    // eslint-disable-next-line no-control-regex -- necesitamos matchear C0 deliberadamente
+    return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+}
+function runProcessList(discovered) {
+    const stderr = diagnosticsToStderr(discovered.diagnostics);
+    if (discovered.models.length === 0) {
+        return { code: 0, stdout: 'No process models declared by the installed registries.\n', stderr };
+    }
+    const rows = discovered.models
+        .map((m) => `${m.name}  ${m.status}  ${m.entryPoint ? 'entry-point' : 'phase'}  -> ${m.terminatesTo}`)
+        .join('\n');
+    return { code: 0, stdout: `${rows}\n`, stderr };
+}
+function runProcessShow(discovered, name, json) {
+    const stderr = diagnosticsToStderr(discovered.diagnostics);
+    const found = discovered.models.find((m) => m.name === name);
+    if (!found) {
+        const available = discovered.models.map((m) => m.name).join(', ') || '(none)';
+        return { code: 2, stdout: '', stderr: `${stderr}awm process show: no process named "${name}" — available: ${available}\n` };
+    }
+    if (!json) {
+        // Vista mínima deliberada: name/status/objective/structure. appliesWhen,
+        // routing, termination y unverified no se renderizan aquí — el detalle
+        // completo del body está disponible vía --json (ver Task 4 del plan R1A).
+        const view = publicView(found);
+        const structure = view.body.structure
+            .map((sg) => [
+            `${stripControlChars(sg.id)} — ${stripControlChars(sg.text)}`,
+            ...sg.operations.map((op) => `  ${stripControlChars(op.id)} — ${stripControlChars(op.text)}`),
+        ].join('\n')).join('\n');
+        return { code: 0, stdout: `${view.name} (${view.status})\n\n${stripControlChars(view.body.objective)}\n\n${structure}\n`, stderr };
+    }
+    return { code: 0, stdout: `${JSON.stringify(publicView(found), null, 2)}\n`, stderr };
+}
+function registerProcessCommand(program) {
+    const process_ = program.command('process').description('declared process models (the CLI is their only parser)');
+    process_
+        .command('list')
+        .description('list process models declared by the installed registries')
+        .action(() => emit(runProcessList((0, discover_1.discoverProcessModels)())));
+    process_
+        .command('show <name>')
+        .description('show one process model')
+        .option('--json', 'emit the parsed model as JSON')
+        .action((name, opts) => emit(runProcessShow((0, discover_1.discoverProcessModels)(), name, opts.json === true)));
+}
+function emit(result) {
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.code !== 0)
+        process.exitCode = result.code;
+}

package/dist/src/core/dashboard/collect.js

@@ -15,6 +15,7 @@ const types_1 = require("../evidence/types");
 const store_1 = require("../ledger/store");
 const paths_1 = require("../journal/paths");
 const store_2 = require("../journal/store");
+const discover_1 = require("../process/discover");
 const sanitize_1 = require("./sanitize");
 const validate_1 = require("./validate");
 const plan_state_1 = require("./plan-state");
@@ -29,7 +30,7 @@ exports.REMEDIATION_BY_FINDING_ID = {
 };
 const BLOCKED_CYCLE_REMEDIATION = 'awm preflight';
 const EMPTY_ADAPTERS = {
-    machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined,
+    machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined, processes: () => [],
 };
 const SAFE_REMEDIATIONS = new Set(['awm init', 'awm update', 'awm sync', 'awm sensors status', 'awm preflight']);
 const HEALTHY_PROVIDER_STATES = new Set(['supported', 'healthy', 'shared', 'delivered']);
@@ -127,6 +128,7 @@ function productionDashboardAdapters(context) {
                 retro: history.cycles.map((cycle) => cycleFinding('retro', 'Project context', cycle, cycle.plan.state !== 'executed')),
             };
         },
+        processes: () => (0, discover_1.discoverProcessModels)().models.map((m) => ({ name: m.name, status: m.status })),
     };
 }
 /** A journal has no durable plan reference. Use a generic fixed row so its
@@ -358,6 +360,29 @@ function collectDashboardSnapshot(options) {
     const retroItems = isolatedFindings(execution?.retro);
     const evidenceResult = optional(() => evidenceHistoryItems(root));
     const executionUnavailable = !executionResult.failed && execution === undefined;
+    const processesResult = optional(() => (0, sanitize_1.sanitizeDashboardSource)(adapters.processes({ root })));
+    // `id`/`label`/`detail` se construyen acá, en código de aplicación, DESPUÉS de
+    // la sanitización de source — igual que `planning` hace con `classifyPlanState`:
+    // el sanitizador descarta todo `detail` que venga del adapter (sanitize.ts), así
+    // que ponerlo antes sería escribirlo para que se borre en silencio. Y como estos
+    // tres campos nunca pasan por el recorrido recursivo de sanitizeDashboardSource
+    // de arriba, se los corre por las mismas ramas de sanitize() (sanitizeDashboardId/
+    // sanitizeDashboardLabel) para sostener la segunda barrera: un `p.name` que no es
+    // slug cae al id hasheado `item-*` en vez de colarse como `process.<bad-name>`.
+    // El estado `attention` es accionable (ver validate.ts): un modelo en draft no
+    // tiene un comando que lo "arregle" — el remediation apunta a inspeccionarlo, no
+    // a resolverlo automáticamente.
+    const processItems = (processesResult.value ?? []).map((p) => ({
+        id: (0, sanitize_1.sanitizeDashboardId)(`process.${p.name}`),
+        // El literal 'Process' ya está en CANONICAL_LABELS, así que el branch
+        // [redacted] de sanitizeDashboardLabel nunca se ejecuta desde este call
+        // site hoy — el wrapper queda por simetría con sanitizeDashboardId y como
+        // guardia ante un futuro label dinámico, no porque esta llamada pueda fallar.
+        label: (0, sanitize_1.sanitizeDashboardLabel)('Process'),
+        state: p.status === 'active' ? 'ok' : 'attention',
+        detail: p.status,
+        ...(p.status === 'active' ? {} : { remediation: 'awm process list' }),
+    }));
     const sections = [
         machineSection,
         section('project', projectResult.failed || projectItemsResult.failed ? 'unavailable' : 'available', projectResult.failed
@@ -371,10 +396,10 @@ function collectDashboardSnapshot(options) {
         section('docs', executionResult.failed || executionUnavailable || docsItems.failed ? 'unavailable' : 'available', docsItems.value),
         section('retro', executionResult.failed || executionUnavailable || retroItems.failed ? 'unavailable' : 'available', retroItems.value),
         section('history', evidenceResult.failed ? 'unavailable' : 'available', evidenceResult.failed ? [] : evidenceResult.value.items),
-        // `processes` is a reserved section id with no adapter yet: a later
-        // release (R1) populates it. `not_applicable` here means exactly
-        // "this section doesn't apply here", not dead code.
-        section('processes', 'not_applicable', []),
+        // R1a puebla `processes` desde su adapter. Sin modelos declarados la
+        // sección conserva `not_applicable` — el mismo valor que R0 dejó
+        // reservado — para que un proyecto sin procesos se vea igual que antes.
+        section('processes', processesResult.failed ? 'unavailable' : processItems.length === 0 ? 'not_applicable' : 'available', processesResult.failed ? [] : processItems),
     ];
     const degraded = sections.some((entry) => entry.availability === 'unavailable' || entry.items.some((item) => item.state !== 'ok' && item.state !== 'not_applicable'));
     return (0, validate_1.validateDashboardSnapshotV1)({ schema: 2, generatedAt: options.now, overall: degraded ? 'degraded' : 'healthy', project: { detected: true, label: projectSource?.label || 'Project detected' }, confidence: evidenceResult.failed ? 'none' : evidenceResult.value.confidence, sections });

package/dist/src/core/dashboard/sanitize.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeDashboardSource = sanitizeDashboardSource;
+exports.sanitizeDashboardId = sanitizeDashboardId;
+exports.sanitizeDashboardLabel = sanitizeDashboardLabel;
 const crypto_1 = require("crypto");
 const STATES = new Set(['ok', 'attention', 'missing', 'unavailable', 'not_applicable', 'active', 'blocked']);
-const ALLOWED_KEYS = new Set(['findings', 'label', 'id', 'state', 'detail', 'remediation', 'remediationVerified', 'execution', 'qa', 'docs', 'retro', 'history', 'lifecycle', 'journal', 'markers', 'tasks', 'total', 'completed', 'qaComplete', 'docsComplete', 'retroComplete']);
+const ALLOWED_KEYS = new Set(['findings', 'label', 'id', 'state', 'detail', 'remediation', 'remediationVerified', 'execution', 'qa', 'docs', 'retro', 'history', 'lifecycle', 'journal', 'markers', 'tasks', 'total', 'completed', 'qaComplete', 'docsComplete', 'retroComplete', 'processes', 'name', 'status']);
 const CANONICAL_LABELS = new Set([
     'Preferences', 'Registries', 'Profile', 'Sensors', 'Optional source unavailable',
     'Extensions', 'Registry pins', 'Active bundles', 'Project context', 'Constitution', 'Static preflight', 'Documentation',
+    'Process',
 ]);
 const CANONICAL_FINDING_IDS = new Set([
     'machine.preferences.missing', 'machine.registries.stale', 'project.profile.missing',
@@ -15,6 +18,10 @@ const CANONICAL_FINDING_IDS = new Set([
 const PROVIDER_FINDING_ID = /^machine\.provider\.(?:claude-code|codex|opencode|cursor|copilot|antigravity)\.(?:binary\.version|skills\.global|agents\.native|workflows\.global|context\.global|hook\.trust|guidance\.project|constitution\.delivery)$/;
 const PROJECT_FINDING_ID = /^project\.(?:profile\.present|extensions\.configured|registry-pins\.present|bundles\.coherent|context\.present|constitution\.present|sensors\.present|preflight\.not_collected)$/;
 const PROVIDER_LABEL = /^Provider (?:claude-code|codex|opencode|cursor|copilot|antigravity): (?:binary\.version|skills\.global|agents\.native|workflows\.global|context\.global|hook\.trust|guidance\.project|constitution\.delivery)$/;
+// El slug ya lo validó PROCESS_NAME en core/process/model.ts. Repetir la forma
+// acá es deliberado: este módulo es la frontera de render y no puede confiar en
+// que su input pasó por aquel validador — un adapter nuevo podría no hacerlo.
+const PROCESS_FINDING_ID = /^process\.[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 const DANGEROUS = /(?:ghp_|sk-[A-Za-z]|<|>|\\\\[^\\\s]+\\[^\\\s]+|\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*|[A-Za-z]:\\|\b[A-Za-z_][A-Za-z0-9_]*=|token|secret|password)/iu;
 function sanitize(value, key) {
     if (value === null || typeof value === 'boolean')
@@ -33,7 +40,7 @@ function sanitize(value, key) {
         if (key === 'id') {
             if (value.trim() === '')
                 throw new Error('Dashboard finding id is invalid');
-            return CANONICAL_FINDING_IDS.has(value) || PROVIDER_FINDING_ID.test(value) || PROJECT_FINDING_ID.test(value)
+            return CANONICAL_FINDING_IDS.has(value) || PROVIDER_FINDING_ID.test(value) || PROJECT_FINDING_ID.test(value) || PROCESS_FINDING_ID.test(value)
                 ? value : `item-${(0, crypto_1.createHash)('sha256').update(value).digest('hex').slice(0, 16)}`;
         }
         if (key === 'label' && !CANONICAL_LABELS.has(value) && !PROVIDER_LABEL.test(value))
@@ -60,3 +67,18 @@ function sanitize(value, key) {
 function sanitizeDashboardSource(value) {
     return sanitize(value);
 }
+// Sections that build an item's `id`/`label` in application code (rather than
+// receiving them ready-made inside an adapter's `findings` array) never pass
+// through `sanitizeDashboardSource`'s recursive walk — there is no `findings`
+// array for it to walk. These wrappers let such call sites run the exact same
+// `id`/`label` branches sanitize() applies to every other section, so a
+// constructed value gets the same canonical-vocabulary / hashed-fallback
+// treatment instead of skipping validation entirely.
+/** Validates a dashboard item id against the canonical id vocabulary, falling back to a hashed id otherwise. */
+function sanitizeDashboardId(value) {
+    return sanitize(value, 'id');
+}
+/** Validates a dashboard item label against the canonical label vocabulary, redacting it otherwise. */
+function sanitizeDashboardLabel(value) {
+    return sanitize(value, 'label');
+}

package/dist/src/core/process/body.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProcessBody = parseProcessBody;
+const REQUIRED = ['Objetivo', 'Cuándo aplica', 'Estructura', 'Ruteo', 'Terminación', 'Sin verificar'];
+const SG = /^-\s+(SG-\d+)\s+—\s+(.+)$/;
+const OP = /^\s+-\s+(OP-(\d+)\.\d+)\s+—\s+(.+)$/;
+// Mismo razonamiento que MAX_FIELD_LENGTH en orchestrators.ts: este texto
+// llega al payload de contexto de un proveedor de IA, así que ningún campo
+// puede ser ilimitado — un `## Objetivo` de 10MB en un registry no confiable
+// debe rechazarse con diagnóstico, no aceptarse. Dos anchos, no uno, porque
+// las secciones de prosa (Objetivo/Cuándo aplica/Terminación) son párrafos
+// libres que legítimamente exceden una sola oración, mientras que los ítems
+// estructurales (texto de SG-#/OP-#, celdas de la tabla Ruteo, entradas de
+// "Sin verificar") son título-cortos por contrato — igual de acotados que los
+// campos de orchestrators.ts.
+const MAX_SECTION_LENGTH = 5000;
+const MAX_ITEM_LENGTH = 500;
+/** Corta el documento en secciones de nivel 2. Las de nivel 1 (`# Titulo`) y el
+ *  contenido previo al primer `##` se descartan: el contrato vive en los `##`.
+ *  Un heading repetido NO se fusiona con el anterior — eso corrompería en
+ *  silencio los parsers posicionales (p.ej. `parseRouting` tomaría la fila de
+ *  cabecera de la segunda sección como una fila de datos). En su lugar se
+ *  registra como problema y el llamador debe abortar. */
+function splitSections(source, problems) {
+    const out = new Map();
+    const seen = new Set();
+    let current = null;
+    for (const line of source.split(/\r?\n/)) {
+        // Greedy capture a fin-de-línea + trim en código, no en el regex: un
+        // `(.+?)` perezoso seguido de `\s*` sobre una clase que lo solapa
+        // (`.` incluye `\s`) es ReDoS cuadrático — ver AGENTS.md
+        // "regex-cuantificador-adyacente-a-clase-que-lo-solapa" y el mismo
+        // patrón ya corregido en cli/src/commands/evidence/index.ts marker().
+        const m = /^##\s+(.*)$/.exec(line);
+        // Un `##` seguido solo de espacio (grupo capturado vacío tras el trim)
+        // NO es un heading real: la regex vieja `(.+?)\s*$` exigía al menos un
+        // carácter no-blanco antes del `\s*$` final, así que una línea así
+        // nunca matcheaba como sección. `(.*)` sí puede capturar cero
+        // caracteres — sin este guard, una línea "## " perdida dentro de p.ej.
+        // `## Ruteo` abriría una sección fantasma "" y desviaría las filas de
+        // tabla reales hacia ella en silencio (ver finding-1 del reviewer).
+        if (m && m[1].trim() !== '') {
+            const heading = m[1].trim();
+            if (seen.has(heading)) {
+                problems.push(`duplicate section heading "## ${heading}"`);
+                current = null; // deja de recolectar: no fusionar con la primera aparición
+                continue;
+            }
+            seen.add(heading);
+            out.set(heading, []);
+            current = heading;
+            continue;
+        }
+        if (current !== null)
+            out.get(current).push(line);
+    }
+    return out;
+}
+function paragraph(lines) {
+    return lines.map((l) => l.trim()).filter((l) => l !== '').join(' ');
+}
+function parseStructure(lines, problems) {
+    const subgoals = [];
+    const seenSg = new Set();
+    for (const raw of lines) {
+        if (raw.trim() === '')
+            continue;
+        const sg = SG.exec(raw);
+        if (sg) {
+            // Un SG-# repetido produciría dos entradas con el mismo `id` en
+            // `structure` — inconsistente para cualquier consumidor que
+            // indexe por id. Mismo patrón `problems` que el resto del archivo.
+            if (seenSg.has(sg[1])) {
+                problems.push(`duplicate "Estructura" id ${sg[1]}`);
+                continue;
+            }
+            seenSg.add(sg[1]);
+            const text = sg[2].trim();
+            if (text.length > MAX_ITEM_LENGTH) {
+                problems.push(`"${sg[1]}" text must be at most ${MAX_ITEM_LENGTH} characters`);
+                continue;
+            }
+            subgoals.push({ id: sg[1], text, operations: [] });
+            continue;
+        }
+        const op = OP.exec(raw);
+        if (!op) {
+            problems.push(`"Estructura" line is neither an SG-# nor an OP-#: ${JSON.stringify(raw.trim().slice(0, 80))}`);
+            continue;
+        }
+        const owner = subgoals[subgoals.length - 1];
+        // El prefijo numérico de la operación DEBE coincidir con su subobjetivo:
+        // sin esto, OP-9.1 colgando de SG-2 pasaría y la jerarquía HTA sería una
+        // ilusión tipográfica.
+        if (!owner) {
+            problems.push(`${op[1]} appears before any SG-#`);
+            continue;
+        }
+        if (`SG-${op[2]}` !== owner.id) {
+            problems.push(`${op[1]} does not belong to ${owner.id}`);
+            continue;
+        }
+        const opText = op[3].trim();
+        if (opText.length > MAX_ITEM_LENGTH) {
+            problems.push(`"${op[1]}" text must be at most ${MAX_ITEM_LENGTH} characters`);
+            continue;
+        }
+        owner.operations.push({ id: op[1], text: opText });
+    }
+    if (subgoals.length === 0)
+        problems.push('"Estructura" declares no SG-#');
+    return subgoals;
+}
+function parseRouting(lines, problems) {
+    const rows = [];
+    const tableLines = lines.map((l) => l.trim()).filter((l) => l.startsWith('|'));
+    for (const [index, line] of tableLines.entries()) {
+        // `| a | b |` -> ['a','b']: se descartan los extremos vacíos que deja el
+        // split, no las celdas internas vacías — la columna "Estado requerido"
+        // vacía es WCP18 "sin hito", un valor con significado.
+        const cells = line.split('|').slice(1, -1).map((c) => c.trim());
+        if (index === 0) {
+            if (cells.length !== 4)
+                problems.push('"Ruteo" header must have exactly 4 columns');
+            continue;
+        }
+        // Separador GFM: dashes puros (`|---|`) o con colons de alineación
+        // (`|:---|:---:|`). Se prueba celda por celda con un regex anclado y
+        // sin cuantificadores anidados (`^:?-+:?$`) — lineal, sin riesgo ReDoS
+        // — y se exige que cada celda tenga al menos un `-` real para no
+        // aceptar una fila de solo colons/vacíos como falso separador.
+        if (cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c)))
+            continue; // separador
+        if (cells.length !== 4) {
+            problems.push(`"Ruteo" row ${index} must have exactly 4 columns, found ${cells.length}`);
+            continue;
+        }
+        if (cells[0] === '' || cells[2] === '' || cells[3] === '') {
+            problems.push(`"Ruteo" row ${index} needs Cuándo, Va a and Termina en`);
+            continue;
+        }
+        if (cells.some((c) => c.length > MAX_ITEM_LENGTH)) {
+            problems.push(`"Ruteo" row ${index} has a cell longer than ${MAX_ITEM_LENGTH} characters`);
+            continue;
+        }
+        rows.push({ when: cells[0], requiredState: cells[1], goesTo: cells[2], endsAt: cells[3] });
+    }
+    if (rows.length === 0)
+        problems.push('"Ruteo" declares no transitions');
+    return rows;
+}
+function parseProcessBody(source, file) {
+    const problems = [];
+    const sections = splitSections(source, problems);
+    for (const heading of REQUIRED) {
+        if (!sections.has(heading))
+            problems.push(`missing required section "## ${heading}"`);
+    }
+    if (problems.length > 0)
+        return { diagnostics: [`${file}: invalid process model body — ${problems.join('; ')}`] };
+    const structure = parseStructure(sections.get('Estructura'), problems);
+    const routing = parseRouting(sections.get('Ruteo'), problems);
+    const objective = paragraph(sections.get('Objetivo'));
+    const appliesWhen = paragraph(sections.get('Cuándo aplica'));
+    const termination = paragraph(sections.get('Terminación'));
+    const unverified = sections.get('Sin verificar')
+        .map((l) => l.trim()).filter((l) => l.startsWith('- ')).map((l) => l.slice(2).trim());
+    for (const [label, value] of [['Objetivo', objective], ['Cuándo aplica', appliesWhen], ['Terminación', termination]]) {
+        if (value === '')
+            problems.push(`"${label}" is empty`);
+        else if (value.length > MAX_SECTION_LENGTH)
+            problems.push(`"${label}" must be at most ${MAX_SECTION_LENGTH} characters`);
+    }
+    for (const [index, entry] of unverified.entries()) {
+        if (entry.length > MAX_ITEM_LENGTH)
+            problems.push(`"Sin verificar" entry ${index} must be at most ${MAX_ITEM_LENGTH} characters`);
+    }
+    if (problems.length > 0)
+        return { diagnostics: [`${file}: invalid process model body — ${problems.join('; ')}`] };
+    return { model: { objective, appliesWhen, structure, routing, termination, unverified }, diagnostics: [] };
+}

package/dist/src/core/process/discover.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverProcessModels = discoverProcessModels;
+// cli/src/core/process/discover.ts
+// Enumera modelos de proceso entre todos los registries instalados.
+//
+// Reusa discoverSkills (core/discovery.ts) para listar cada root: no re-camina
+// el filesystem, delega en ella la lectura del directorio `skills/` y la
+// descripción del SKILL.md. Pero se la llama UN ROOT A LA VEZ, no con todos
+// los roots juntos.
+//
+// Motivo: discoverSkills lanza cuando dos roots tienen una skill con el MISMO
+// nombre de carpeta y ningún override declarado — esa es la política correcta
+// para identidad de skill, pero un modelo de proceso se identifica por su
+// `name` de frontmatter, no por el nombre de su carpeta. Si se le pasaran
+// todos los roots juntos, una colisión de nombre-de-carpeta entre dos
+// registries (con o sin relación entre sí) tumbaría el descubrimiento de
+// TODOS los modelos de proceso de TODOS los registries — justo lo que R7.1
+// prohíbe. El dedupe real de modelos ocurre acá abajo, por `name`, con
+// diagnóstico en vez de excepción; ver `collectDeclaredOrchestrators` para el
+// mismo criterio ("gana el primero en orden de roots").
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const registries_1 = require("../registries");
+const discovery_1 = require("../discovery");
+const model_1 = require("./model");
+const body_1 = require("./body");
+function discoverProcessModels(roots = (0, registries_1.contentRoots)()) {
+    const models = [];
+    const diagnostics = [];
+    const seen = new Set();
+    for (const root of roots) {
+        let skills;
+        try {
+            skills = (0, discovery_1.discoverSkills)([root]);
+        }
+        catch (e) {
+            // Con un solo root, discoverSkills no debería lanzar por colisión
+            // (no hay con qué colisionar) — pero sí puede lanzar por I/O. Un
+            // registry roto no debe impedir descubrir los demás (R7.1).
+            diagnostics.push(`${root}: process model discovery unavailable (${e instanceof Error ? e.message : String(e)})`);
+            continue;
+        }
+        for (const skill of skills) {
+            const file = path_1.default.join(skill.path, 'SKILL.md');
+            // Same trust boundary as readDeclaredOrchestrators (orchestrators.ts):
+            // a registry is untrusted input, and SKILL.md is registry-declared content.
+            // assertRegularRegistryFile throws when the file is a symlink (or otherwise
+            // not a regular file), which would let a malicious/compromised registry point
+            // at an arbitrary local file and have its content read. This module's
+            // discipline is "never throws" — a broken/malicious skill must not block
+            // discovery of the others — so the rejection is caught here and turned into a
+            // diagnostic (naming only the path, never the symlink target's content).
+            let exists;
+            try {
+                exists = (0, registries_1.assertRegularRegistryFile)(file);
+            }
+            catch (e) {
+                diagnostics.push(`${file}: cannot read (${e instanceof Error ? e.message : String(e)})`);
+                continue;
+            }
+            if (!exists) {
+                diagnostics.push(`${file}: cannot read (ENOENT: no such file)`);
+                continue;
+            }
+            let source;
+            try {
+                source = fs_1.default.readFileSync(file, 'utf-8');
+            }
+            catch (e) {
+                diagnostics.push(`${file}: cannot read (${e instanceof Error ? e.message : String(e)})`);
+                continue;
+            }
+            const front = (0, model_1.parseProcessFrontmatter)(source, file);
+            diagnostics.push(...front.diagnostics);
+            if (!front.model)
+                continue; // no es un modelo, o está roto
+            const body = (0, body_1.parseProcessBody)(source, file);
+            diagnostics.push(...body.diagnostics);
+            if (!body.model)
+                continue;
+            if (seen.has(front.model.name)) {
+                diagnostics.push(`${file}: process "${front.model.name}" duplicates one already declared by an earlier registry — shadowed duplicate dropped`);
+                continue;
+            }
+            seen.add(front.model.name);
+            models.push({ ...front.model, source: file, body: body.model });
+        }
+    }
+    return { models, diagnostics };
+}

package/dist/src/core/process/model.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROCESS_NAME = void 0;
+exports.parseProcessFrontmatter = parseProcessFrontmatter;
+// cli/src/core/process/model.ts
+// Lector del contrato de frontmatter del modelo durable de proceso.
+// Disciplina heredada literal de core/orchestrators.ts: NUNCA lanza. Un modelo
+// malformado se rechaza con diagnóstico y no invalida al registry que lo
+// contiene ni a los demás (R7.1).
+const frontmatter_1 = require("../frontmatter");
+const types_1 = require("./types");
+/** El discriminador es literal: ningún documento se reconoce como modelo por su
+ *  cuerpo, sus headings ni su nombre de archivo (R1.2). */
+const DISCRIMINATOR = 'process-model';
+const ALLOWED_FIELDS = ['awm', 'schema', 'name', 'status', 'entry_point', 'terminates_to', 'created', 'updated'];
+const STATUSES = ['draft', 'active'];
+/** El slug es lo único del modelo que puede viajar dentro de un id del Dashboard
+ *  (ver sanitize.ts). Por eso se valida acá y no en la frontera de render: si
+ *  admitiera rutas, markup o `=`, el id dejaría de ser seguro por construcción. */
+exports.PROCESS_NAME = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+/** Lector de pares `clave: valor` de un frontmatter plano. El contrato no admite
+ *  anidamiento ni block scalars, así que no se arrastra un parser YAML: cualquier
+ *  línea que no sea `clave: valor` es un rechazo, no una interpretación. */
+function readPairs(block) {
+    const pairs = new Map();
+    const problems = [];
+    for (const raw of block.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        const m = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/.exec(line);
+        if (!m) {
+            problems.push(`line is not a "key: value" pair: ${JSON.stringify(line.slice(0, 80))}`);
+            continue;
+        }
+        if (pairs.has(m[1])) {
+            problems.push(`duplicate field ${JSON.stringify(m[1])}`);
+            continue;
+        }
+        pairs.set(m[1], m[2].trim());
+    }
+    return { pairs, problems };
+}
+function parseProcessFrontmatter(source, file) {
+    let block;
+    try {
+        block = (0, frontmatter_1.matchFrontmatterBlock)(source);
+    }
+    catch {
+        return { diagnostics: [] };
+    }
+    if (block === null)
+        return { diagnostics: [] };
+    const { pairs, problems } = readPairs(block);
+    // Sin discriminador NO es un modelo de proceso: no es un error, es otro
+    // documento. Devolver diagnóstico acá inundaría de ruido a todo registry
+    // (cada SKILL.md normal caería en esta rama).
+    if (pairs.get('awm') !== DISCRIMINATOR)
+        return { diagnostics: [] };
+    for (const key of pairs.keys()) {
+        if (!ALLOWED_FIELDS.includes(key)) {
+            problems.push(`unknown field ${JSON.stringify(key)} — the contract admits only ${ALLOWED_FIELDS.join(', ')}`);
+        }
+    }
+    const rawSchema = pairs.get('schema');
+    const schema = rawSchema !== undefined && /^\d+$/.test(rawSchema) ? Number(rawSchema) : Number.NaN;
+    if (!Number.isInteger(schema) || schema < 1) {
+        problems.push('"schema" must be a positive integer');
+    }
+    else if (schema > types_1.KNOWN_PROCESS_SCHEMA) {
+        // R1.4: detenerse e informar. Interpretarlo como el contrato anterior es
+        // exactamente lo que este branch existe para impedir.
+        return { diagnostics: [`${file}: process model declares schema ${schema}, but this CLI understands up to ${types_1.KNOWN_PROCESS_SCHEMA} — install a newer agentic-workflow-manager to read it`] };
+    }
+    for (const field of ['name', 'status', 'entry_point', 'terminates_to', 'created', 'updated']) {
+        const value = pairs.get(field);
+        if (value === undefined || value === '')
+            problems.push(`"${field}" is required`);
+    }
+    const name = pairs.get('name') ?? '';
+    if (name !== '' && !exports.PROCESS_NAME.test(name))
+        problems.push('"name" must be a lowercase slug (a-z, 0-9, hyphen)');
+    const status = pairs.get('status') ?? '';
+    if (status !== '' && !STATUSES.includes(status))
+        problems.push(`"status" must be one of ${STATUSES.join(', ')}`);
+    const entryPointRaw = pairs.get('entry_point') ?? '';
+    if (entryPointRaw !== '' && entryPointRaw !== 'true' && entryPointRaw !== 'false')
+        problems.push('"entry_point" must be true or false');
+    const terminatesTo = pairs.get('terminates_to') ?? '';
+    if (terminatesTo !== '' && terminatesTo !== 'none' && !exports.PROCESS_NAME.test(terminatesTo)) {
+        problems.push('"terminates_to" must be a lowercase slug or "none"');
+    }
+    for (const field of ['created', 'updated']) {
+        const value = pairs.get(field) ?? '';
+        if (value !== '' && !DATE.test(value))
+            problems.push(`"${field}" must be YYYY-MM-DD`);
+    }
+    if (problems.length > 0) {
+        return { diagnostics: [`${file}: invalid process model — ${problems.join('; ')}`] };
+    }
+    return {
+        model: {
+            schema, name, status: status, entryPoint: entryPointRaw === 'true',
+            terminatesTo, created: pairs.get('created'), updated: pairs.get('updated'),
+        },
+        diagnostics: [],
+    };
+}

package/dist/src/core/process/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_PROCESS_SCHEMA = void 0;
+/** Máximo schema que este CLI sabe evaluar. Solo crece (R1.3). */
+exports.KNOWN_PROCESS_SCHEMA = 1;

package/dist/src/index.js

@@ -42,6 +42,7 @@ const job_1 = require("./commands/job");
 const watch_1 = require("./commands/watch");
 const track_1 = require("./commands/track");
 const evidence_1 = require("./commands/evidence");
+const process_1 = require("./commands/process");
 const add_1 = require("./commands/add");
 const sync_1 = require("./commands/sync");
 const update_1 = require("./commands/update");
@@ -735,6 +736,7 @@ miroCmd.command('sync <storyMapPath>')
 (0, watch_1.registerWatchCommand)(program);
 (0, track_1.registerTrackCommand)(program);
 (0, evidence_1.registerEvidenceCommand)(program);
+(0, process_1.registerProcessCommand)(program);
 // Commander only waits for async action handlers through parseAsync().  The CLI has
 // async commands (including `sensors coverage`), so returning its promise keeps the
 // process alive until their JSON/output contract has been completed.