agentic-workflow-manager 9.1.0 → 9.2.0

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContextOrchestrators = runContextOrchestrators;
+exports.registerContextCommand = registerContextCommand;
+const orchestrators_1 = require("../../core/orchestrators");
+const provider_1 = require("../../core/context/provider");
+const text_1 = require("../../core/text");
+const command_result_1 = require("../../core/command-result");
+function runContextOrchestrators(collected, opts) {
+    const stderr = (0, command_result_1.diagnosticsToStderr)(collected.diagnostics);
+    const composed = (0, provider_1.composedOrchestrators)(collected.declared);
+    if (opts.verify !== undefined) {
+        // opts.verify es el argumento CRUDO tal como lo tipeo el usuario; composed[].name
+        // ya paso por sanitizeDeclaredField. Sin normalizar este lado con la MISMA funcion,
+        // un usuario que tipee el nombre declarado exacto (con un caracter que el saneo
+        // quita, p.ej. `_` o un byte de control) se lleva un falso "not composed" (R3.5/R3.6).
+        const verifyNormalized = (0, text_1.sanitizeDeclaredField)(opts.verify);
+        const found = composed.some((o) => o.name === verifyNormalized);
+        if (!found) {
+            const available = composed.map((o) => o.name).join(', ') || '(none)';
+            return {
+                code: 2, stdout: '',
+                stderr: `${stderr}awm context orchestrators: "${verifyNormalized}" is not composed — available: ${available}\n`,
+            };
+        }
+        return { code: 0, stdout: `"${verifyNormalized}" is composed into the session context.\n`, stderr };
+    }
+    if (opts.json) {
+        return { code: 0, stdout: `${JSON.stringify({ orchestrators: composed }, null, 2)}\n`, stderr };
+    }
+    if (composed.length === 0) {
+        return { code: 0, stdout: 'No declared orchestrators in the installed registries.\n', stderr };
+    }
+    const rows = composed
+        .map((o) => `${o.name}  applies when: ${o.appliesWhen}  -> ${o.terminatesTo}`)
+        .join('\n');
+    return { code: 0, stdout: `${rows}\n`, stderr };
+}
+function registerContextCommand(program) {
+    const context = program.command('context').description('read-only view of the context AWM delivers to every agent session');
+    context
+        .command('orchestrators')
+        .description('list the declared orchestrators as they are composed into the session context')
+        .option('--json', 'emit the composed list as JSON')
+        .option('--verify <name>', 'exit 0 only if that orchestrator is composed; 2 otherwise')
+        .action((opts) => (0, command_result_1.emit)(runContextOrchestrators((0, orchestrators_1.collectDeclaredOrchestrators)(), { json: opts.json === true, verify: opts.verify })));
+}

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

@@ -4,6 +4,8 @@ exports.runProcessList = runProcessList;
 exports.runProcessShow = runProcessShow;
 exports.registerProcessCommand = registerProcessCommand;
 const discover_1 = require("../../core/process/discover");
+const text_1 = require("../../core/text");
+const command_result_1 = require("../../core/command-result");
 /** `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. */
@@ -11,25 +13,8 @@ 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);
+    const stderr = (0, command_result_1.diagnosticsToStderr)(discovered.diagnostics);
     if (discovered.models.length === 0) {
         return { code: 0, stdout: 'No process models declared by the installed registries.\n', stderr };
     }
@@ -39,7 +24,7 @@ function runProcessList(discovered) {
     return { code: 0, stdout: `${rows}\n`, stderr };
 }
 function runProcessShow(discovered, name, json) {
-    const stderr = diagnosticsToStderr(discovered.diagnostics);
+    const stderr = (0, command_result_1.diagnosticsToStderr)(discovered.diagnostics);
     const found = discovered.models.find((m) => m.name === name);
     if (!found) {
         const available = discovered.models.map((m) => m.name).join(', ') || '(none)';
@@ -52,10 +37,10 @@ function runProcessShow(discovered, name, json) {
         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)}`),
+            `${(0, text_1.stripControlChars)(sg.id)} — ${(0, text_1.stripControlChars)(sg.text)}`,
+            ...sg.operations.map((op) => `  ${(0, text_1.stripControlChars)(op.id)} — ${(0, text_1.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: `${view.name} (${view.status})\n\n${(0, text_1.stripControlChars)(view.body.objective)}\n\n${structure}\n`, stderr };
     }
     return { code: 0, stdout: `${JSON.stringify(publicView(found), null, 2)}\n`, stderr };
 }
@@ -64,18 +49,10 @@ function registerProcessCommand(program) {
     process_
         .command('list')
         .description('list process models declared by the installed registries')
-        .action(() => emit(runProcessList((0, discover_1.discoverProcessModels)())));
+        .action(() => (0, command_result_1.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;
+        .action((name, opts) => (0, command_result_1.emit)(runProcessShow((0, discover_1.discoverProcessModels)(), name, opts.json === true)));
 }

package/dist/src/core/command-result.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnosticsToStderr = diagnosticsToStderr;
+exports.emit = emit;
+/** Formatea diagnósticos como líneas `warning: ...\n` listas para stderr.
+ *  Compartido entre comandos para no divergir el formato. */
+function diagnosticsToStderr(diagnostics) {
+    return diagnostics.map((d) => `warning: ${d}\n`).join('');
+}
+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/context/provider.js

@@ -4,11 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sha256 = sha256;
+exports.composedOrchestrators = composedOrchestrators;
 exports.buildContext = buildContext;
 // cli/src/core/context/provider.ts
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const text_1 = require("../text");
 function sha256(input) {
     return crypto_1.default.createHash('sha256').update(input, 'utf-8').digest('hex');
 }
@@ -17,29 +19,36 @@ function parseVersion(skill) {
     return m ? m[1].trim() : '0.0.0';
 }
 /**
- * Neutraliza contenido no confiable proveniente de registries declarados
- * (name/appliesWhen/terminatesTo) antes de interpolarlo en 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. `readDeclaredOrchestrators` solo valida que los
- * campos sean strings no vacios; el saneo pertenece a esta frontera de
- * render, no a la validacion de lectura.
+ * La lista de orquestadores declarados TAL COMO entra al payload de contexto:
+ * saneada campo por campo con `sanitizeDeclaredField` (core/text.ts) — que
+ * neutraliza tanto marcado markdown/saltos de linea (prompt-injection via
+ * `##`, `` ` ``, `*`, `_`, `<`, `>`) COMO bytes de control C0/DEL (ANSI
+ * escapes hacia una terminal real). `readDeclaredOrchestrators` solo valida
+ * que los campos sean strings no vacios; el saneo pertenece a esta frontera
+ * de render, no a la validacion de lectura.
+ *
+ * ESTA es la UNICA funcion que hace este saneo — es la que consume
+ * `renderDeclared` (el payload materializado en cada sesion de agente via
+ * `buildContext`) y la que consume `awm context orchestrators` (comando).
+ * Ningun consumidor necesita sanear de nuevo por su cuenta: si el comando
+ * aplicara su propio saneo, comando y payload podrian divergir en silencio
+ * — el modo de falla que R5.2 prohíbe para el modelo de proceso y que vale
+ * igual acá. Por la misma razon, cualquier comparacion contra un nombre
+ * declarado (p.ej. `--verify` en `commands/context/index.ts`) debe normalizar
+ * su lado tambien con `sanitizeDeclaredField`, no con una copia del regex.
  */
-function sanitizeForMarkdown(s) {
-    return s.replace(/\r?\n/g, ' ').replace(/[`*_#<>]/g, '');
+function composedOrchestrators(list) {
+    return list.map(o => ({
+        name: (0, text_1.sanitizeDeclaredField)(o.name),
+        appliesWhen: (0, text_1.sanitizeDeclaredField)(o.appliesWhen),
+        terminatesTo: (0, text_1.sanitizeDeclaredField)(o.terminatesTo),
+    }));
 }
 function renderDeclared(list) {
     if (list.length === 0)
         return '';
-    const rows = list
-        .map(o => {
-        const name = sanitizeForMarkdown(o.name);
-        const appliesWhen = sanitizeForMarkdown(o.appliesWhen);
-        const terminatesTo = sanitizeForMarkdown(o.terminatesTo);
-        return `- **${name}** — applies when: ${appliesWhen}. Terminates to: \`${terminatesTo}\`.`;
-    })
+    const rows = composedOrchestrators(list)
+        .map(o => `- **${o.name}** — applies when: ${o.appliesWhen}. Terminates to: \`${o.terminatesTo}\`.`)
         .join('\n');
     return `## Declared orchestrators\n\nConsider these before the built-in pair:\n\n${rows}\n\n`;
 }

package/dist/src/core/orchestrators.js

@@ -17,6 +17,7 @@ exports.collectAndWarn = collectAndWarn;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const registries_1 = require("./registries");
+const text_1 = require("./text");
 const ALLOWED_FIELDS = ['name', 'appliesWhen', 'terminatesTo'];
 // These fields are semantically short (a short identity, a short trigger condition, a
 // short target name) — no legitimate declaration needs more than this. A registry is
@@ -109,21 +110,41 @@ function readDeclaredOrchestrators(root) {
  * de emitir ambas filas al markdown compuesto, gana la primera en el orden de
  * listRegistries() (= orden de registries.json, ver registries.ts) y la duplicada se
  * descarta con un diagnostico — misma degradacion tolerante (reportar, no lanzar) que el
- * resto de este modulo (R1.2, R5.1).
+ * resto de este modulo (R1.2, R5.1). `orch.name` es contenido no confiable del registry:
+ * se pasa por `stripControlChars` (core/text.ts) antes de interpolarlo en el diagnostico,
+ * que termina crudo en stderr real via `command-result.ts`'s `diagnosticsToStderr`/`emit`.
+ *
+ * Ademas del dedupe por nombre CRUDO, dos orquestadores con nombres crudos distintos
+ * (p.ej. `foo_bar` y `foo*bar`) pueden colisionar DESPUES del saneo que aplica
+ * `composedOrchestrators` (core/context/provider.ts) — ambos renderizarian como el mismo
+ * `foobar` visible, sin explicacion. Como son declaraciones genuinamente distintas, no se
+ * descarta ninguna (eso perderia una declaracion real) — se emite un diagnostico
+ * accionable en su lugar. `sanitizeDeclaredField` vive en core/text.ts (no en provider.ts)
+ * precisamente para que este modulo -- que debe seguir siendo hoja y no puede importar
+ * context/provider.ts, el cual ya importa `DeclaredOrchestrator` DESDE este archivo -- pueda
+ * calcular el mismo nombre saneado sin duplicar el regex.
  */
 function collectDeclaredOrchestrators() {
     const declared = [];
     const diagnostics = [];
     const seenNames = new Set();
+    const seenSanitizedNames = new Set();
     for (const reg of (0, registries_1.listRegistries)()) {
         const r = readDeclaredOrchestrators(reg.contentRoot);
         for (const orch of r.orchestrators) {
+            const file = path_1.default.join(reg.contentRoot, registries_1.REGISTRY_MANIFEST_NAME);
             if (seenNames.has(orch.name)) {
-                const file = path_1.default.join(reg.contentRoot, registries_1.REGISTRY_MANIFEST_NAME);
-                diagnostics.push(`${file}: orchestrator "${orch.name}" duplicates one already declared by an earlier registry — shadowed duplicate dropped`);
+                diagnostics.push(`${file}: orchestrator "${(0, text_1.stripControlChars)(orch.name)}" duplicates one already declared by an earlier registry — shadowed duplicate dropped`);
                 continue;
             }
             seenNames.add(orch.name);
+            const sanitizedName = (0, text_1.sanitizeDeclaredField)(orch.name);
+            if (seenSanitizedNames.has(sanitizedName)) {
+                diagnostics.push(`${file}: orchestrator "${(0, text_1.stripControlChars)(orch.name)}" sanitizes to the same composed name "${sanitizedName}" as an already declared orchestrator — both will render as indistinguishable duplicates in the composed context`);
+            }
+            else {
+                seenSanitizedNames.add(sanitizedName);
+            }
             declared.push(orch);
         }
         diagnostics.push(...r.diagnostics);

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

@@ -43,6 +43,7 @@ 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");
@@ -737,6 +738,7 @@ miroCmd.command('sync <storyMapPath>')
 (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/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}.`);
+    });
+});

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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.1.0",
+  "version": "9.2.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"