agentic-workflow-manager 9.20.2 → 9.20.3

package/dist/src/core/frontmatter.js

@@ -24,11 +24,71 @@ exports.matchFrontmatterBlock = matchFrontmatterBlock;
 exports.isBlockScalarHeader = isBlockScalarHeader;
 exports.findFrontmatterDescription = findFrontmatterDescription;
 exports.readFrontmatterDescription = readFrontmatterDescription;
+/** Tope del contenido interno (entre `---` y el cerrador) antes de abandonar el
+ *  escaneo (FH-3). Misma cifra que `FRONTMATTER_MAX` en process/model.ts. */
+const FRONTMATTER_INNER_MAX = 65536;
+/** ¿La linea es exactamente el cerrador `---` con espacios/tabs finales opcionales?
+ *  `---x`, `---#comment` y similares NO cierran. */
+function isFrontmatterCloserLine(line) {
+    if (!line.startsWith('---'))
+        return false;
+    for (let i = 3; i < line.length; i++) {
+        const c = line[i];
+        if (c !== ' ' && c !== '\t')
+            return false;
+    }
+    return true;
+}
 /** Texto crudo del frontmatter (entre los delimitadores `---`), o null si el
- *  bloque falta o esta mal formado. Tolera CRLF. */
+ *  bloque falta o esta mal formado. Tolera CRLF. Cierra solo en una linea que
+ *  sea exactamente `---` (con espacios/tabs finales opcionales). Si el contenido
+ *  interno excederia `FRONTMATTER_INNER_MAX` antes de un cerrador valido, retorna
+ *  null sin seguir acumulando lineas (FH-3). */
 function matchFrontmatterBlock(raw) {
-    const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    return fmMatch ? fmMatch[1] : null;
+    if (!raw.startsWith('---'))
+        return null;
+    const afterOpen = raw[3] === '\r' && raw[4] === '\n' ? 5
+        : raw[3] === '\n' ? 4
+            : -1;
+    if (afterOpen < 0)
+        return null;
+    const body = raw.slice(afterOpen);
+    const lines = [];
+    let innerLen = 0;
+    let i = 0;
+    while (i <= body.length) {
+        let end = i;
+        while (end < body.length && body[end] !== '\n' && body[end] !== '\r')
+            end++;
+        const line = body.slice(i, end);
+        if (isFrontmatterCloserLine(line)) {
+            return lines.join('\n');
+        }
+        // join('\n') inserta un salto entre lineas ya acumuladas.
+        const nextLen = lines.length === 0 ? line.length : innerLen + 1 + line.length;
+        if (nextLen > FRONTMATTER_INNER_MAX)
+            return null;
+        lines.push(line);
+        innerLen = nextLen;
+        if (end >= body.length)
+            break;
+        if (body[end] === '\r' && body[end + 1] === '\n')
+            i = end + 2;
+        else
+            i = end + 1;
+    }
+    return null;
+}
+/** Quita un comentario YAML de escalar plano: solo `#` precedido de espacio o
+ *  tab (no NBSP ni otros whitespace Unicode). Lineal en la longitud del valor. */
+function stripPlainScalarComment(value) {
+    for (let i = 0; i < value.length - 1; i++) {
+        const c = value[i];
+        if ((c === ' ' || c === '\t') && value[i + 1] === '#') {
+            return value.slice(0, i).trim();
+        }
+    }
+    return value.trim();
 }
 /** Indicador de block scalar en la linea de la clave: estilo (`>` folded /
  *  `|` literal) + chomping opcional (`-`/`+`) + indentacion explicita opcional
@@ -212,10 +272,11 @@ function findFrontmatterDescription(frontmatter) {
             }
         }
     }
-    // Escalar plano: un `#` PRECEDIDO DE ESPACIO abre un comentario y no forma
-    // parte del valor (un `#` pegado a texto, como en `C#`, si). Dentro de
+    // Escalar plano: un `#` PRECEDIDO DE ESPACIO O TAB abre un comentario y no
+    // forma parte del valor (un `#` pegado a texto, como en `C#`, si; NBSP
+    // antes de `#` tampoco abre comentario — alineado con js-yaml). Dentro de
     // comillas el `#` es literal, y esas ramas ya retornaron.
-    return { value: value.replace(/\s+#.*$/, '').trim(), startLine, endLine };
+    return { value: stripPlainScalarComment(value), startLine, endLine };
 }
 /** Azucar para el caso comun: solo el valor resuelto de `description`. */
 function readFrontmatterDescription(frontmatter) {

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

@@ -24,8 +24,16 @@ const ALLOWED_FIELDS = ['awm', 'schema', 'name', 'status', 'entry_point', 'termi
 const DESCRIPTION_MAX = 1024;
 /** Tope del bloque de frontmatter antes de entregarlo al parser YAML: acota el
  *  costo de parsear contenido no confiable de un registry. Por encima no se
- *  parsea (para `description`, se rechaza con el mensaje del límite de 1024). */
+ *  parsea (para `description`, se rechaza con el mensaje del límite de 1024).
+ *  Para un bloque con discriminador `awm: process-model`, también corta
+ *  `readPairs` (FH-5). */
 const FRONTMATTER_MAX = 65536;
+/** Tope de problemas acumulados en un solo diagnóstico de proceso (FH-6). */
+const MAX_PROCESS_PROBLEMS = 20;
+/** Tope de caracteres de una clave desconocida/duplicada embebida en el diagnóstico (FH-6). */
+const UNKNOWN_FIELD_KEY_MAX = 64;
+/** Tope del valor crudo de `name`/`terminates_to` antes de `yaml.load` (FH-4). */
+const YAML_SCALAR_RAW_MAX = 128;
 /** Lo que un runtime mostraría mal o usaría para engañar: controles C0 (salvo
  *  tab), DEL, C1, separadores U+2028/U+2029, marcas LRM/RLM/ALM, overrides e
  *  isolates bidi, y surrogates sueltos (regex en vez de `isWellFormed`: el lib
@@ -34,7 +42,50 @@ const FORBIDDEN_CHAR = /[\u0000-\u0008\u000A-\u001F\u007F-\u009F\u061C\u200E\u20
 /** Discriminador indentado: un modelo cuyas claves quedaron con sangría se
  *  perdería en silencio como "no es un modelo". */
 const INDENTED_DISCRIMINATOR = /^awm[ \t]*:[ \t]*process-model$/;
+/** Discriminador a nivel de línea (sin sangría) para el gate de tamaño FH-5. */
+const PROCESS_MODEL_DISCRIMINATOR_LINE = /^awm[ \t]*:[ \t]*process-model[ \t]*$/m;
+/** Discriminador en prefijo (columna 0 o indentado) cuando matchFrontmatterBlock
+ *  devolvió null por exceso de tamaño (FH-5 QA amend). */
+const PROCESS_MODEL_DISCRIMINATOR_PREFIX = /^[ \t]*awm[ \t]*:[ \t]*process-model[ \t]*$/m;
+/** Token de ancla/alias YAML con forma `&name` / `*name` (FH-4). */
+const YAML_ALIAS_TOKEN = /[&*][A-Za-z0-9_-]+/;
 const STATUSES = ['draft', 'active'];
+/** Sentinel cuando `loadYamlScalar` no obtiene un mapeo plano con clave `v`. */
+const YAML_SCALAR_MISS = Symbol('yaml-scalar-miss');
+/** Quita un comentario de escalar plano (` #…` / `\t#…`) solo para el guard FH-4. */
+function stripTrailingPlainCommentForGuard(raw) {
+    for (let i = 0; i < raw.length - 1; i++) {
+        const c = raw[i];
+        if ((c === ' ' || c === '\t') && raw[i + 1] === '#')
+            return raw.slice(0, i);
+    }
+    return raw;
+}
+/** Carga un valor suelto de `readPairs` como escalar YAML (`v: <raw>`). NUNCA lanza.
+ *  Rechaza sin parsear si el raw (sin comentario final) es demasiado largo o trae
+ *  un token de ancla/alias con forma `&name` / `*name`. */
+function loadYamlScalar(raw) {
+    const forGuard = stripTrailingPlainCommentForGuard(raw);
+    if (forGuard.length > YAML_SCALAR_RAW_MAX || YAML_ALIAS_TOKEN.test(forGuard))
+        return YAML_SCALAR_MISS;
+    try {
+        const doc = js_yaml_1.default.load(`v: ${raw}`);
+        if (isPlainObject(doc) && Object.prototype.hasOwnProperty.call(doc, 'v'))
+            return doc.v;
+    }
+    catch { /* invalid YAML → miss */ }
+    return YAML_SCALAR_MISS;
+}
+/** Si `raw` es un escalar string YAML, lo devuelve; si no (null/bool/number/…), `null`. */
+function yamlStringSlug(raw) {
+    const value = loadYamlScalar(raw);
+    return typeof value === 'string' ? value : null;
+}
+/** Clave truncada para diagnósticos `unknown field` / `duplicate field` (FH-6). */
+function formatFieldKey(key) {
+    const shown = key.length > UNKNOWN_FIELD_KEY_MAX ? `${key.slice(0, UNKNOWN_FIELD_KEY_MAX)}…` : key;
+    return JSON.stringify(shown);
+}
 /** 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. */
@@ -42,13 +93,21 @@ exports.PROCESS_NAME = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 const DATE = /^\d{4}-\d{2}-\d{2}$/;
 /** Caracteres de ancho cero: un valor hecho solo de ellos se ve vacío. */
 const ZERO_WIDTH = /[\u200B-\u200D\u2060\uFEFF]/g;
+/** Empuja a `problems` mientras haya cupo (FH-6); cuenta el resto en `omitted`. */
+function noteProblem(problems, omitted, msg) {
+    if (problems.length < MAX_PROCESS_PROBLEMS)
+        problems.push(msg);
+    else
+        omitted.n++;
+}
 /** Lector de pares `clave: valor` de un frontmatter plano. El contrato no admite
  *  anidamiento ni block scalars: cualquier línea que no sea `clave: valor` es un
  *  rechazo, no una interpretación. (El VALOR de `description` sí pasa por el
- *  parser YAML, más abajo.) */
+ *  parser YAML, más abajo.) Deja de registrar problemas tras 20 (FH-6). */
 function readPairs(block) {
     const pairs = new Map();
     const problems = [];
+    const omitted = { n: 0 };
     const continuations = [];
     // Mismo criterio que YAML, no que JS: se parte en TODO salto de línea YAML
     // (un CR suelto también; si no, `a\rclave: x` sería un par para acá y dos
@@ -60,8 +119,9 @@ function readPairs(block) {
         // NEL/LS/PS son saltos de línea para YAML 1.1 (PyYAML) y no para js-yaml:
         // un comentario podría esconder una clave que solo un runtime ve. Se
         // reporta en CUALQUIER línea, comentarios incluidos, y solo por posición.
-        if (/[\u0085\u2028\u2029]/.test(raw))
-            problems.push(`frontmatter line ${index + 1} contains a YAML 1.1 line break (NEL, LS or PS)`);
+        if (/[\u0085\u2028\u2029]/.test(raw)) {
+            noteProblem(problems, omitted, `frontmatter line ${index + 1} contains a YAML 1.1 line break (NEL, LS or PS)`);
+        }
         if (line === '' || line.startsWith('#'))
             continue;
         // El contrato es un mapa PLANO: una línea que empieza con espacio o tab
@@ -78,23 +138,26 @@ function readPairs(block) {
         // contenido: una línea suelta suele ser la continuación de un valor
         // multilínea, y los diagnósticos no transportan valores de campos.
         if (!m) {
-            problems.push(`frontmatter line ${index + 1} is not a "key: value" pair (multi-line values are not supported)`);
+            noteProblem(problems, omitted, `frontmatter line ${index + 1} is not a "key: value" pair (multi-line values are not supported)`);
             continue;
         }
         if (pairs.has(m[1])) {
-            problems.push(`duplicate field ${JSON.stringify(m[1])}`);
+            noteProblem(problems, omitted, `duplicate field ${formatFieldKey(m[1])}`);
             continue;
         }
         pairs.set(m[1], m[2]);
     }
-    return { pairs, problems, continuations };
+    return { pairs, problems, continuations, omittedProblems: omitted.n };
 }
 /** Carga el bloque de frontmatter COMPLETO con js-yaml (schema por defecto),
  *  exactamente como lo lee un runtime. Por encima del tope no se parsea. NUNCA
- *  lanza: un error de js-yaml es `invalid`. */
+ *  lanza: un error de js-yaml es `invalid`. Rechaza sin `yaml.load` si el bloque
+ *  contiene un token de ancla/alias con forma `&name` / `*name` (FH-4). */
 function loadBlock(block) {
     if (block.length > FRONTMATTER_MAX)
         return { kind: 'too-long' };
+    if (YAML_ALIAS_TOKEN.test(block))
+        return { kind: 'invalid' };
     try {
         return { kind: 'loaded', doc: js_yaml_1.default.load(block) };
     }
@@ -168,9 +231,28 @@ function parseProcessFrontmatter(source, file) {
     catch {
         return { diagnostics: [] };
     }
-    if (block === null)
+    const sizeDiag = { diagnostics: [`${file}: invalid process model — frontmatter exceeds ${FRONTMATTER_MAX} characters`] };
+    if (block === null) {
+        // FH-5: match devolvió null (sin cerrador a tiempo / tope interno). Si el
+        // prefijo declara process-model (columna 0 o indentado) → tamaño; si no → silencio.
+        if (source.startsWith('---')) {
+            const prefix = source.slice(0, FRONTMATTER_MAX + 128);
+            if (PROCESS_MODEL_DISCRIMINATOR_PREFIX.test(prefix))
+                return sizeDiag;
+        }
         return { diagnostics: [] };
-    const { pairs, problems, continuations } = readPairs(block);
+    }
+    // FH-5 defensa: bloque devuelto que aun así exceda el tope (no debería pasar
+    // tras FH-3). Con discriminador → tamaño; sin él → silencio.
+    if (block.length > FRONTMATTER_MAX) {
+        if (PROCESS_MODEL_DISCRIMINATOR_LINE.test(block) || PROCESS_MODEL_DISCRIMINATOR_PREFIX.test(block)) {
+            return sizeDiag;
+        }
+        return { diagnostics: [] };
+    }
+    const { pairs, problems, continuations, omittedProblems } = readPairs(block);
+    const omitted = { n: omittedProblems };
+    const note = (msg) => noteProblem(problems, omitted, msg);
     // Un modelo con las claves indentadas no tiene `awm` de nivel superior y se
     // perdería en silencio como "otro documento". Se nombra solo la línea.
     // Dispara con el prefiltro barato y, además, si el bloque NO carga como YAML
@@ -193,13 +275,13 @@ function parseProcessFrontmatter(source, file) {
         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(', ')}`);
+            note(`unknown field ${formatFieldKey(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');
+        note('"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
@@ -209,37 +291,58 @@ function parseProcessFrontmatter(source, file) {
     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`);
+            note(`"${field}" is required`);
+    }
+    const YAML_STRING_DIAG = 'must be a YAML string scalar (quote values YAML reads as null, boolean, or number)';
+    let name = '';
+    const rawName = pairs.get('name') ?? '';
+    if (rawName !== '') {
+        const resolvedName = yamlStringSlug(rawName);
+        if (resolvedName === null)
+            note(`"name" ${YAML_STRING_DIAG}`);
+        else if (!exports.PROCESS_NAME.test(resolvedName))
+            note('"name" must be a lowercase slug (a-z, 0-9, hyphen)');
+        else
+            name = resolvedName;
     }
-    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(', ')}`);
+        note(`"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"');
+        note('"entry_point" must be true or false');
+    let terminatesTo = '';
+    const rawTerminatesTo = pairs.get('terminates_to') ?? '';
+    if (rawTerminatesTo !== '') {
+        const resolvedTerminatesTo = yamlStringSlug(rawTerminatesTo);
+        if (resolvedTerminatesTo === null)
+            note(`"terminates_to" ${YAML_STRING_DIAG}`);
+        else if (resolvedTerminatesTo !== 'none' && !exports.PROCESS_NAME.test(resolvedTerminatesTo)) {
+            note('"terminates_to" must be a lowercase slug or "none"');
+        }
+        else {
+            terminatesTo = resolvedTerminatesTo;
+        }
     }
     for (const field of ['created', 'updated']) {
         const value = pairs.get(field) ?? '';
         if (value !== '' && !DATE.test(value))
-            problems.push(`"${field}" must be YYYY-MM-DD`);
+            note(`"${field}" must be YYYY-MM-DD`);
     }
     let description;
     const rawDescription = pairs.get('description');
     if (rawDescription !== undefined) {
         const checked = checkDescription(rawDescription, block, new Set(pairs.keys()));
         if ('problem' in checked)
-            problems.push(checked.problem);
+            note(checked.problem);
         else
             description = checked.value;
     }
-    if (problems.length > 0) {
-        return { diagnostics: [`${file}: invalid process model — ${problems.join('; ')}`] };
+    if (problems.length > 0 || omitted.n > 0) {
+        const capped = omitted.n > 0
+            ? problems.concat([`${omitted.n} more problems`])
+            : problems;
+        return { diagnostics: [`${file}: invalid process model — ${capped.join('; ')}`] };
     }
     return {
         model: {

package/dist/tests/core/frontmatter-hardening.test.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// FH-1 / FH-2 / FH-3: linear plain-scalar comment strip, YAML-aligned
+// space/tab-before-# vs NBSP, and exact `---` closer for matchFrontmatterBlock.
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const frontmatter_1 = require("../../src/core/frontmatter");
+const helpers_1 = require("./changes/helpers");
+describe('frontmatter hardening (FH-1, FH-2, FH-3)', () => {
+    describe('FH-3: matchFrontmatterBlock closes only on exact ---', () => {
+        it('keeps keys after a ---x line inside the block', () => {
+            const raw = '---\nname: a\n---x: 1\nstatus: b\n---\n\nbody\n';
+            const block = (0, frontmatter_1.matchFrontmatterBlock)(raw);
+            expect(block).not.toBeNull();
+            expect(block).toContain('---x: 1');
+            expect(block).toContain('status: b');
+        });
+        it('closes on --- with trailing spaces', () => {
+            const block = (0, frontmatter_1.matchFrontmatterBlock)('---\nname: a\n--- \n\nbody\n');
+            expect(block).toBe('name: a');
+        });
+        it('closes on --- with trailing tabs and CRLF', () => {
+            const block = (0, frontmatter_1.matchFrontmatterBlock)('---\r\nname: a\r\n---\t\t\r\n\r\nbody\r\n');
+            expect(block).toBe('name: a');
+        });
+        it('does not close on ---#comment', () => {
+            const raw = '---\nname: a\n---#comment\nstatus: b\n---\n\nbody\n';
+            const block = (0, frontmatter_1.matchFrontmatterBlock)(raw);
+            expect(block).not.toBeNull();
+            expect(block).toContain('---#comment');
+            expect(block).toContain('status: b');
+        });
+        it('yields empty string for empty frontmatter', () => {
+            expect((0, frontmatter_1.matchFrontmatterBlock)('---\n---\n')).toBe('');
+        });
+        it('does not close on --- followed by NBSP', () => {
+            const raw = '---\nname: a\n---\u00A0\nstatus: b\n---\n\nbody\n';
+            const block = (0, frontmatter_1.matchFrontmatterBlock)(raw);
+            expect(block).not.toBeNull();
+            expect(block).toContain('---\u00A0');
+            expect(block).toContain('status: b');
+        });
+        it('returns null quickly when open frontmatter would exceed 65536 without a closer', () => {
+            const huge = `---\n${'x'.repeat(70_000)}`;
+            const started = Date.now();
+            expect((0, frontmatter_1.matchFrontmatterBlock)(huge)).toBeNull();
+            expect(Date.now() - started).toBeLessThan(500);
+        });
+        it('returns null when a closer exists only after inner content would exceed 65536', () => {
+            // Without the allocation bound, this would return a 65537-char block.
+            const raw = `---\n${'x'.repeat(65_537)}\n---\n`;
+            const started = Date.now();
+            expect((0, frontmatter_1.matchFrontmatterBlock)(raw)).toBeNull();
+            expect(Date.now() - started).toBeLessThan(500);
+        });
+    });
+    describe('FH-2: comment strip is space/tab only (not NBSP)', () => {
+        it('drops trailing comment after space before #', () => {
+            expect((0, frontmatter_1.findFrontmatterDescription)('description: hello # drop').value).toBe('hello');
+        });
+        it('drops trailing comment after tab before #', () => {
+            expect((0, frontmatter_1.findFrontmatterDescription)('description: hello\t# drop').value).toBe('hello');
+        });
+        it('keeps NBSP before # (matches js-yaml)', () => {
+            const fm = 'description: hello\u00A0# keep';
+            const ours = (0, frontmatter_1.findFrontmatterDescription)(fm).value;
+            const doc = js_yaml_1.default.load(fm);
+            expect(ours).toBe(doc.description);
+            expect(ours).toContain('\u00A0');
+            expect(ours).toContain('# keep');
+        });
+        it('keeps # with no whitespace before it (C#)', () => {
+            expect((0, frontmatter_1.findFrontmatterDescription)('description: usar C# y F#').value).toBe('usar C# y F#');
+        });
+    });
+    describe('FH-1: plain description comment strip is linear-time', () => {
+        it('scales linearly with long runs of spaces and no #', () => {
+            (0, helpers_1.expectLinearScaling)((n) => {
+                (0, frontmatter_1.findFrontmatterDescription)('description: a' + ' '.repeat(n) + 'x');
+            }, 20_000);
+        });
+        it('scales linearly with long runs of tabs and no #', () => {
+            (0, helpers_1.expectLinearScaling)((n) => {
+                (0, frontmatter_1.findFrontmatterDescription)('description: a' + '\t'.repeat(n) + 'x');
+            }, 20_000);
+        });
+    });
+});

package/dist/tests/core/process/model.test.js

@@ -58,6 +58,159 @@ describe('parseProcessFrontmatter', () => {
         const r = (0, model_1.parseProcessFrontmatter)(valid.replace('name: ejemplo-proceso', 'name: ../../etc/passwd'), 'p');
         expect(r.model).toBeUndefined();
     });
+    describe('YAML string slugs (FH-4)', () => {
+        const YAML_STRING = /YAML string scalar|quote values YAML reads as null, boolean, or number/i;
+        it.each(['null', 'true', '0x1f', '1e5', '01'])('rejects bare YAML non-string name: %s', (raw) => {
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('name: ejemplo-proceso', `name: ${raw}`), 'p');
+            expect(r.model).toBeUndefined();
+            expect(r.diagnostics.join(' ')).toMatch(YAML_STRING);
+            expect(r.diagnostics.join(' ')).toMatch(/"name"/);
+        });
+        it.each([
+            ['"null"', 'null'],
+            ['"demo-ok"', 'demo-ok'],
+        ])('accepts quoted YAML string name %s', (raw, expected) => {
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('name: ejemplo-proceso', `name: ${raw}`), 'p');
+            expect(r.diagnostics).toEqual([]);
+            expect(r.model?.name).toBe(expected);
+        });
+        it('rejects terminates_to loaded as a non-string', () => {
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('terminates_to: none', 'terminates_to: 0x1f'), 'p');
+            expect(r.model).toBeUndefined();
+            expect(r.diagnostics.join(' ')).toMatch(YAML_STRING);
+            expect(r.diagnostics.join(' ')).toMatch(/"terminates_to"/);
+        });
+        it.each(['none', '"none"'])('accepts terminates_to %s as none', (raw) => {
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('terminates_to: none', `terminates_to: ${raw}`), 'p');
+            expect(r.diagnostics).toEqual([]);
+            expect(r.model?.terminatesTo).toBe('none');
+        });
+        it('rejects a nested-alias bomb in name without calling yaml.load on it', () => {
+            // Classic self-referential alias expansion; the pre-load guard must
+            // refuse &/* (and never hang) before js-yaml sees the value.
+            const bomb = '&a [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]';
+            const load = jest.spyOn(js_yaml_1.default, 'load');
+            try {
+                const started = Date.now();
+                const r = (0, model_1.parseProcessFrontmatter)(valid.replace('name: ejemplo-proceso', `name: ${bomb}`), 'p');
+                expect(Date.now() - started).toBeLessThan(500);
+                expect(r.model).toBeUndefined();
+                expect(r.diagnostics.join(' ')).toMatch(YAML_STRING);
+                expect(r.diagnostics.join(' ')).toMatch(/"name"/);
+                expect(load.mock.calls.some(([arg]) => String(arg).includes(bomb))).toBe(false);
+                expect(load.mock.calls.some(([arg]) => /[&*]/.test(String(arg)))).toBe(false);
+            }
+            finally {
+                load.mockRestore();
+            }
+        });
+        it('rejects a name raw longer than 128 characters without calling yaml.load on it', () => {
+            const raw = `"${'a'.repeat(129)}"`;
+            expect(raw.length).toBeGreaterThan(128);
+            const load = jest.spyOn(js_yaml_1.default, 'load');
+            try {
+                const r = (0, model_1.parseProcessFrontmatter)(valid.replace('name: ejemplo-proceso', `name: ${raw}`), 'p');
+                expect(r.model).toBeUndefined();
+                expect(r.diagnostics.join(' ')).toMatch(YAML_STRING);
+                expect(load.mock.calls.some(([arg]) => String(arg).includes(raw))).toBe(false);
+            }
+            finally {
+                load.mockRestore();
+            }
+        });
+        it('accepts name with a trailing plain comment that contains * (guard strips comment)', () => {
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('name: ejemplo-proceso', 'name: my-proc # tag*'), 'p');
+            expect(r.diagnostics).toEqual([]);
+            expect(r.model?.name).toBe('my-proc');
+        });
+        it('rejects a description block with an alias-shaped token without calling yaml.load on the block', () => {
+            // Alias token lives in a comment so readPairs stays clean; loadBlock must
+            // refuse before yaml.load (same alias class as FH-4 slug guard). Slug
+            // loads (`v: …`) may still run; the full block must not.
+            const withDesc = valid.replace('updated: 2026-08-23', 'updated: 2026-08-23\ndescription: "ok"\n# &hostile_alias');
+            const load = jest.spyOn(js_yaml_1.default, 'load');
+            try {
+                const r = (0, model_1.parseProcessFrontmatter)(withDesc, 'p');
+                expect(r.model).toBeUndefined();
+                expect(r.diagnostics.join(' ')).toMatch(/"description" cannot be read: the frontmatter is not valid YAML/);
+                expect(load.mock.calls.some(([arg]) => String(arg).includes('&hostile_alias'))).toBe(false);
+                expect(load.mock.calls.some(([arg]) => String(arg).includes('description:'))).toBe(false);
+            }
+            finally {
+                load.mockRestore();
+            }
+        });
+        it('accepts a quoted description with bare & that is not an alias token', () => {
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('updated: 2026-08-23', 'updated: 2026-08-23\ndescription: "foo & bar"'), 'p');
+            expect(r.diagnostics).toEqual([]);
+            expect(r.model?.description).toBe('foo & bar');
+        });
+    });
+    describe('bounded frontmatter diagnostics (FH-5, FH-6)', () => {
+        const FRONTMATTER_MAX = 65536;
+        const blockOf = (source) => source.slice(4, source.indexOf('\n---', 4));
+        const withBlockLength = (source, target) => {
+            const pad = target - blockOf(source).length - 3;
+            const next = source.replace('\ncreated:', `\n# ${'x'.repeat(pad)}\ncreated:`);
+            expect(blockOf(next)).toHaveLength(target);
+            return next;
+        };
+        it('rejects an oversized process-model block with a size diagnostic and no model', () => {
+            const source = withBlockLength(valid, FRONTMATTER_MAX + 1);
+            const load = jest.spyOn(js_yaml_1.default, 'load');
+            try {
+                const r = (0, model_1.parseProcessFrontmatter)(source, 'p');
+                expect(r.model).toBeUndefined();
+                expect(r.diagnostics.join(' ')).toMatch(/frontmatter exceeds 65536 characters/);
+                expect(load).not.toHaveBeenCalled();
+            }
+            finally {
+                load.mockRestore();
+            }
+        });
+        it('stays silent for an oversized block without the process-model discriminator and never calls yaml.load', () => {
+            const source = withBlockLength(valid.replace('awm: process-model\n', ''), FRONTMATTER_MAX + 1);
+            const load = jest.spyOn(js_yaml_1.default, 'load');
+            try {
+                const r = (0, model_1.parseProcessFrontmatter)(source, 'p');
+                expect(r.model).toBeUndefined();
+                expect(r.diagnostics).toEqual([]);
+                expect(load).not.toHaveBeenCalled();
+            }
+            finally {
+                load.mockRestore();
+            }
+        });
+        it('caps process-model problems at 20 and reports the remainder count', () => {
+            const extras = Array.from({ length: 25 }, (_, i) => `unknown_${i}: x`).join('\n');
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('created:', `${extras}\ncreated:`), 'p');
+            expect(r.model).toBeUndefined();
+            const joined = r.diagnostics.join(' ');
+            const unknownMentions = joined.match(/unknown field/g) ?? [];
+            expect(unknownMentions.length).toBe(20);
+            expect(joined).toContain('5 more problems');
+        });
+        it('truncates unknown field keys longer than 64 characters with an ellipsis', () => {
+            const longKey = `k${'a'.repeat(199)}`;
+            expect(longKey).toHaveLength(200);
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('created:', `${longKey}: x\ncreated:`), 'p');
+            expect(r.model).toBeUndefined();
+            const joined = r.diagnostics.join(' ');
+            expect(joined).toMatch(/unknown field/);
+            expect(joined).toContain(`${'a'.repeat(63)}…`);
+            expect(joined).not.toContain(longKey);
+        });
+        it('truncates duplicate field keys longer than 64 characters with an ellipsis', () => {
+            const longKey = `d${'b'.repeat(199)}`;
+            expect(longKey).toHaveLength(200);
+            const r = (0, model_1.parseProcessFrontmatter)(valid.replace('created:', `${longKey}: a\n${longKey}: b\ncreated:`), 'p');
+            expect(r.model).toBeUndefined();
+            const joined = r.diagnostics.join(' ');
+            expect(joined).toMatch(/duplicate field/);
+            expect(joined).toContain(`${'b'.repeat(63)}…`);
+            expect(joined).not.toContain(longKey);
+        });
+    });
     it('nunca lanza ante entrada basura', () => {
         for (const junk of ['', '---\n', '---\n\x00\n---\n', 'no frontmatter']) {
             expect(() => (0, model_1.parseProcessFrontmatter)(junk, 'p')).not.toThrow();
@@ -208,13 +361,15 @@ describe('parseProcessFrontmatter', () => {
             expect(r.diagnostics).toEqual([]);
             expect(r.model?.description).toBe('ok');
         });
-        it('rejects a frontmatter block over 65536 characters with the 1024 message without parsing it', () => {
+        it('rejects a frontmatter block over 65536 characters at the size gate without parsing it', () => {
+            // FH-5: process-model discriminator + oversized block → size diagnostic
+            // before readPairs / description YAML load (no longer the 1024 path).
             const source = withBlockLength(65537);
             const load = jest.spyOn(js_yaml_1.default, 'load');
             try {
                 const r = (0, model_1.parseProcessFrontmatter)(source, 'p');
                 expect(r.model).toBeUndefined();
-                expect(r.diagnostics.join(' ')).toMatch(/"description" must be at most 1024 characters/);
+                expect(r.diagnostics.join(' ')).toMatch(/frontmatter exceeds 65536 characters/);
                 expect(load).not.toHaveBeenCalled();
             }
             finally {
@@ -404,13 +559,15 @@ describe('parseProcessFrontmatter', () => {
             expect(r.model).toBeUndefined();
             expect(r.diagnostics.join(' ')).not.toMatch(/must not be indented/);
         });
-        it('reports an indented discriminator in a block over 65536 characters without loading it', () => {
+        it('rejects an oversized indented process-model with a size diagnostic and never calls yaml.load', () => {
+            // FH-5 (QA amend): indented awm: process-model in an oversized/unclosed
+            // prefix must surface the size diagnostic, not silence.
             const source = indentAll(valid.replace('\ncreated:', `\n# ${'x'.repeat(65536)}\ncreated:`));
             const load = jest.spyOn(js_yaml_1.default, 'load');
             try {
-                expect((0, model_1.parseProcessFrontmatter)(source, 'p')).toEqual({
-                    diagnostics: ['p: invalid process model — frontmatter keys must not be indented (frontmatter line 1)'],
-                });
+                const r = (0, model_1.parseProcessFrontmatter)(source, 'p');
+                expect(r.model).toBeUndefined();
+                expect(r.diagnostics.join(' ')).toMatch(/frontmatter exceeds 65536 characters/);
                 expect(load).not.toHaveBeenCalled();
             }
             finally {

package/package.json

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