agentic-workflow-manager 9.0.2 → 9.2.0

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/core/text.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripControlChars = stripControlChars;
+exports.sanitizeDeclaredField = sanitizeDeclaredField;
+// cli/src/core/text.ts
+/** Neutraliza bytes de control C0 (incluyendo ESC `\x1b`) y DEL de texto que
+ *  proviene de un registry no confiable antes de escribirlo a una terminal
+ *  humana. `\n` y `\t` se preservan porque son whitespace legítimo.
+ *
+ *  Vive en core/ y no dentro de un comando porque tiene DOS consumidores:
+ *  `awm process show` (vista de texto del modelo) y `awm context orchestrators`
+ *  (campos declarados por un registry). Duplicarlo es la forma exacta que
+ *  `AGENTS.md` documenta bajo `defensive-guard-consistency`: endurecer una copia
+ *  y dejar la otra atrás. */
+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, '');
+}
+/**
+ * Neutraliza marcado markdown (colapsa `\r?\n` a un espacio y quita
+ * `` ` * _ # < > ``) de contenido no confiable antes de interpolarlo en un
+ * bloque markdown. Sin esto, un registry malicioso/comprometido podria
+ * inyectar saltos de linea, marcadores markdown o pseudo-tags XML/HTML para
+ * forjar una seccion nueva o un bloque instruccional dentro del payload de
+ * contexto que consume el proveedor de IA — un vector de prompt-injection.
+ */
+function sanitizeMarkdown(s) {
+    return s.replace(/\r?\n/g, ' ').replace(/[`*_#<>]/g, '');
+}
+/**
+ * Saneo COMPLETO de un campo de orquestador declarado (name/appliesWhen/
+ * terminatesTo) proveniente de un registry no confiable: primero
+ * `sanitizeMarkdown` (colapsa saltos de linea, quita marcado markdown), y
+ * DESPUES `stripControlChars` (quita bytes de control C0/DEL). Ese orden
+ * importa: `sanitizeMarkdown` colapsa `\r?\n` a un espacio antes de que
+ * `stripControlChars` pueda tocarlos — aunque `stripControlChars` preserva
+ * `\n`/`\t` de todos modos, para cuando corre ya no queda ninguno.
+ *
+ * Unica fuente de verdad para este saneo: `composedOrchestrators`
+ * (core/context/provider.ts) lo aplica a cada campo antes de que llegue al
+ * payload de contexto materializado, y cualquier otro punto del CLI que
+ * necesite el mismo nombre normalizado (p.ej. `--verify` en
+ * `commands/context/index.ts`, o la deteccion de colisiones post-saneo en
+ * `core/orchestrators.ts`) debe importar y reusar esta funcion en vez de
+ * reimplementar el regex — ver AGENTS.md
+ * `reusar-guarda-de-symlink-en-lectores-de-contenido-de-registry` para el
+ * patron general de no duplicar guardas sobre contenido de registry.
+ *
+ * Vive en core/text.ts (hoja pura, cero dependencias) en vez de en
+ * provider.ts porque `core/orchestrators.ts` tambien debe consumirla (para
+ * detectar colisiones post-saneo entre nombres crudos distintos) y
+ * `orchestrators.ts` no puede importar `context/provider.ts`: provider.ts ya
+ * importa el tipo `DeclaredOrchestrator` DESDE orchestrators.ts, asi que
+ * importar en la direccion contraria cerraria un ciclo real.
+ */
+function sanitizeDeclaredField(s) {
+    return stripControlChars(sanitizeMarkdown(s));
+}

package/dist/src/index.js

@@ -42,6 +42,8 @@ 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 context_1 = require("./commands/context");
 const add_1 = require("./commands/add");
 const sync_1 = require("./commands/sync");
 const update_1 = require("./commands/update");
@@ -735,6 +737,8 @@ miroCmd.command('sync <storyMapPath>')
 (0, watch_1.registerWatchCommand)(program);
 (0, track_1.registerTrackCommand)(program);
 (0, evidence_1.registerEvidenceCommand)(program);
+(0, process_1.registerProcessCommand)(program);
+(0, context_1.registerContextCommand)(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.

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_1 = require("../../src/commands/context");
+const collected = (declared, diagnostics = []) => ({ declared, diagnostics });
+const uno = { name: 'mi-proceso', appliesWhen: 'cuando hay una tarea', terminatesTo: 'development-process' };
+describe('awm context orchestrators', () => {
+    it('lista los orquestadores compuestos', () => {
+        const r = (0, context_1.runContextOrchestrators)(collected([uno]), { json: false });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toContain('mi-proceso');
+        expect(r.stdout).toContain('development-process');
+    });
+    it('sin declarados sale 0 y lo dice, no falla', () => {
+        const r = (0, context_1.runContextOrchestrators)(collected([]), { json: false });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toMatch(/no declared orchestrators/i);
+    });
+    it('emite los diagnosticos sin dejar de listar los sanos', () => {
+        const r = (0, context_1.runContextOrchestrators)(collected([uno], ['/r/awm-registry.json: boom']), { json: false });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toContain('mi-proceso');
+        expect(r.stderr).toContain('boom');
+    });
+    it('--json emite la lista compuesta como JSON', () => {
+        const r = (0, context_1.runContextOrchestrators)(collected([uno]), { json: true });
+        expect(r.code).toBe(0);
+        expect(JSON.parse(r.stdout)).toEqual({ orchestrators: [uno] });
+    });
+    it('--verify sale 0 cuando el nombre esta compuesto', () => {
+        const r = (0, context_1.runContextOrchestrators)(collected([uno]), { json: false, verify: 'mi-proceso' });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toMatch(/composed/i);
+    });
+    it('--verify sale 2 y nombra lo disponible cuando no esta', () => {
+        const r = (0, context_1.runContextOrchestrators)(collected([uno]), { json: false, verify: 'no-existe' });
+        expect(r.code).toBe(2);
+        expect(r.stderr).toContain('no-existe');
+        expect(r.stderr).toContain('mi-proceso');
+    });
+    it('--verify sale 0 cuando el nombre declarado tiene caracteres que el saneo quita', () => {
+        // El nombre REAL declarado por el registry es 'task_capture' (con guion bajo).
+        // composed[].name sale saneado ('taskcapture'), pero el usuario tipea el nombre
+        // declarado EXACTO via --verify — eso debe seguir contando como compuesto.
+        const declarado = { name: 'task_capture', appliesWhen: 'x', terminatesTo: 'y' };
+        const r = (0, context_1.runContextOrchestrators)(collected([declarado]), { json: false, verify: 'task_capture' });
+        expect(r.code).toBe(0);
+        expect(r.stdout).toMatch(/composed/i);
+    });
+    it('--verify normaliza markdown-especiales del argumento antes de comparar', () => {
+        const declarado = { name: 'foo*bar#baz', appliesWhen: 'x', terminatesTo: 'y' };
+        const r = (0, context_1.runContextOrchestrators)(collected([declarado]), { json: false, verify: 'foo*bar#baz' });
+        expect(r.code).toBe(0);
+    });
+    it('--verify sigue saliendo 2 para un nombre genuinamente ausente', () => {
+        const r = (0, context_1.runContextOrchestrators)(collected([uno]), { json: false, verify: 'de-verdad-no-existe' });
+        expect(r.code).toBe(2);
+    });
+    it('sanea bytes de control antes de escribir a la terminal', () => {
+        const hostil = { name: 'x\x1b[31m', appliesWhen: 'w\x07', terminatesTo: 't\x00' };
+        const r = (0, context_1.runContextOrchestrators)(collected([hostil]), { json: false });
+        // eslint-disable-next-line no-control-regex -- verificamos la ausencia deliberada de C0
+        expect(r.stdout).not.toMatch(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/);
+    });
+});

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/context/provider.test.js

@@ -180,3 +180,52 @@ describe('buildContext — declared orchestrators', () => {
 // NOTE: the 'generic robustness invariant' test that validated specific prose in the
 // using-awm SKILL.md has been removed — content now lives in awm-baseline-registry
 // (an external repo), not in this monorepo. Content-level tests belong there.
+describe('composedOrchestrators', () => {
+    it('devuelve los valores tal como entran al payload, ya saneados', () => {
+        const out = (0, provider_1.composedOrchestrators)([
+            { name: 'mi-proceso', appliesWhen: 'cuando *algo*', terminatesTo: 'development-process' },
+        ]);
+        expect(out).toEqual([
+            { name: 'mi-proceso', appliesWhen: 'cuando algo', terminatesTo: 'development-process' },
+        ]);
+    });
+    it('neutraliza saltos de linea y markdown estructural', () => {
+        const out = (0, provider_1.composedOrchestrators)([
+            { name: 'x', appliesWhen: 'a\n## Forjado', terminatesTo: '`b`' },
+        ]);
+        expect(out[0].appliesWhen).toBe('a  Forjado');
+        expect(out[0].terminatesTo).toBe('b');
+    });
+    it('neutraliza bytes de control C0 (p.ej. ESC) ademas del markdown', () => {
+        const out = (0, provider_1.composedOrchestrators)([
+            { name: 'a\x1bx', appliesWhen: 'w\x07', terminatesTo: 't\x00' },
+        ]);
+        expect(out[0].name).toBe('ax');
+        // eslint-disable-next-line no-control-regex -- verificamos la ausencia deliberada de C0
+        const controlCharPattern = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/;
+        expect(out[0].name).not.toMatch(controlCharPattern);
+        expect(out[0].appliesWhen).not.toMatch(controlCharPattern);
+        expect(out[0].terminatesTo).not.toMatch(controlCharPattern);
+    });
+    it('el payload materializado (buildContext) tampoco contiene bytes de control de un orquestador declarado', () => {
+        const root = tmpRegistry('---\nname: using-awm\nversion: "1.0.0"\n---\nBODY');
+        const ctx = (0, provider_1.buildContext)({
+            registryRoot: root,
+            profileExtensions: [],
+            declaredOrchestrators: [
+                { name: 'evil\x1b[31m', appliesWhen: 'w', terminatesTo: 't' },
+            ],
+        });
+        // eslint-disable-next-line no-control-regex -- verificamos la ausencia deliberada de C0
+        expect(ctx.markdown).not.toMatch(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/);
+    });
+    it('lo que renderiza el payload sale de esta misma funcion', () => {
+        // Si renderDeclared dejara de consumirla, el comando y el payload
+        // podrian divergir en silencio — que es el modo de falla que R5.2 prohibe.
+        const declared = [{ name: 'p', appliesWhen: 'w', terminatesTo: 't' }];
+        const composed = (0, provider_1.composedOrchestrators)(declared);
+        const reg = tmpRegistry('---\nname: using-awm\nversion: "1.0.0"\n---\nBODY');
+        const ctx = (0, provider_1.buildContext)({ registryRoot: reg, profileExtensions: [], declaredOrchestrators: declared });
+        expect(ctx.markdown).toContain(`- **${composed[0].name}** — applies when: ${composed[0].appliesWhen}.`);
+    });
+});