agentic-workflow-manager 9.20.1 → 9.20.3

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

@@ -475,7 +475,7 @@ function registerChangeCommand(program, deps = {}) {
     change
         .command('new <slug>')
         .description('create docs/changes/YYYY-MM-DD-<slug>.md with derived fields and pending narrative')
-        .option('--base <ref>', 'base branch (default: origin/HEAD, main, master)')
+        .option('--base <ref>', range_1.BASE_OPTION_HELP)
         .option('--plan <path>', 'repo-relative plan file to link')
         .option('--issue <url>', 'https issue URL to link')
         .option('--model <model>', 'provenance: model identifier')
@@ -485,7 +485,7 @@ function registerChangeCommand(program, deps = {}) {
     change
         .command('validate [path]')
         .description('validate the Change Record(s) added by this branch, or one record (--strict also checks the sensor receipt)')
-        .option('--base <ref>', 'base branch (default: origin/HEAD, main, master)')
+        .option('--base <ref>', range_1.BASE_OPTION_HELP)
         .option('--strict', 'require a matching, passing sensor receipt for verification.commit')
         .option('--json', 'print a single JSON line')
         .action((target, opts) => inCwd((cwd) => runChangeValidate(cwd, target, opts), wantsJson(opts)));

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

@@ -10,6 +10,7 @@ const command_1 = require("../../core/changes/command");
 const git_1 = require("../../core/changes/git");
 const list_1 = require("../../core/changes/list");
 const list_parse_1 = require("../../core/changes/list-parse");
+const range_1 = require("../../core/changes/range");
 const render_list_1 = require("../../core/changes/render-list");
 const text_safety_1 = require("../../core/changes/text-safety");
 const FORMATS = ['text', 'json', 'voice'];
@@ -78,7 +79,7 @@ function registerChangesCommand(program, deps = {}) {
         .command('list')
         .description('list the changes of the base branch with their Change Record and derived merge/release state')
         .option('--since <window>', '<n>h, <n>d or YYYY-MM-DD (default 24h)')
-        .option('--base <ref>', 'base branch (default: origin/HEAD, main, master)')
+        .option('--base <ref>', range_1.BASE_OPTION_HELP)
         .option('--format <format>', 'text | json | voice (default text)')
         .action((opts) => (0, command_1.inCwd)((cwd) => runChangesList(cwd, opts, deps), () => (0, command_1.fail)('not-a-git-repo', 'the working directory is not accessible')));
 }

package/dist/src/core/changes/derive.js

@@ -15,6 +15,7 @@ const types_1 = require("./types");
 // Pathspecs relative to the repository top, so the result does not depend on the directory git runs in.
 const ALL_FILES = ':/';
 const EXCLUDE_RECORDS = `:(top,exclude,literal)${types_1.RECORD_DIR}`;
+const EXCLUDE_PLANS = ':(top,exclude,literal)docs/plans';
 const PARSER_TYPE = /^\w+$/;
 const RECORD_TYPE = /^[a-z]+$/;
 const MODULE_DEPTH = 3;
@@ -39,18 +40,22 @@ function usable(commits) {
 }
 const byCodeUnit = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 /**
- * R3.3. `breaking` and `semver` cover every usable commit, with the release parser's exact-type semantics; the recorded type is
- * the highest-impact commit's type lowercased, or `other` when that is still not purely letters. Null when no commit is usable.
+ * R3.3 as amended 2026-10-19. `breaking` and `semver` cover every usable commit, with the release parser's exact-type semantics.
+ * `type` and `scope` come from the usable `focus` commits (those touching a path outside docs/changes/ and docs/plans/), or from
+ * every usable commit when `focus` is omitted or has none. The recorded type is the highest-impact chosen commit's type
+ * lowercased, or `other` when that is still not purely letters. Null when no commit is usable.
  */
-function deriveFromCommits(input) {
+function deriveFromCommits(input, focusInput) {
     const commits = usable(input);
     if (commits.length === 0)
         return null;
+    const focused = usable(focusInput);
+    const chooser = focused.length > 0 ? focused : commits;
     const breaking = commits.some((c) => c.breaking);
-    const pick = commits.find((c) => c.breaking) ?? commits.find((c) => c.type === 'feat') ?? commits.find((c) => c.type === 'fix')
-        ?? commits.find((c) => c.type === 'perf') ?? commits[0];
+    const pick = chooser.find((c) => c.breaking) ?? chooser.find((c) => c.type === 'feat') ?? chooser.find((c) => c.type === 'fix')
+        ?? chooser.find((c) => c.type === 'perf') ?? chooser[0];
     const counts = new Map();
-    for (const c of commits)
+    for (const c of chooser)
         if (c.scope)
             counts.set(c.scope, (counts.get(c.scope) ?? 0) + 1);
     const scope = [...counts.entries()].sort((a, b) => b[1] - a[1] || byCodeUnit(a[0], b[0]))[0]?.[0] ?? null;
@@ -87,6 +92,8 @@ function commitsFromRecords(records) {
 const fail = (code, message) => ({ ok: false, diagnostic: { code, message: (0, text_safety_1.clipMessage)(message) } });
 /**
  * Derives from the non-merge commits in mergeBaseSha..HEAD, ignoring commits and files that only touch docs/changes/.
+ * R3.3 amended: `type` and `scope` come from the commits that also touch a path outside docs/plans/ (all of them when no
+ * conventional commit does), while `semver` and `breaking` cover every commit.
  * `mergeBaseSha` must be a full commit id (the output of `mergeBase`); anything else is `invalid-input`.
  */
 function deriveFields(root, mergeBaseSha) {
@@ -103,14 +110,20 @@ function deriveFields(root, mergeBaseSha) {
     // (`merge -s ours`), silently dropping real commits from the range.
     // -z ends every commit with NUL, which a message cannot contain: each record is exactly one commit, so a message that
     // embeds the parser's own separator cannot be read as a second commit.
-    const raw = (0, git_1.runGit)(root, ['log', ...git_1.LOG_SAFETY_ARGS, '--no-merges', '--full-history', '--reverse', '-z', `--format=${core_1.GIT_LOG_FORMAT}`, '--end-of-options', range, '--', ALL_FILES, EXCLUDE_RECORDS]);
+    const logArgs = ['log', ...git_1.LOG_SAFETY_ARGS, '--no-merges', '--full-history', '--reverse', '-z', `--format=${core_1.GIT_LOG_FORMAT}`, '--end-of-options', range, '--', ALL_FILES, EXCLUDE_RECORDS];
+    const raw = (0, git_1.runGit)(root, logArgs);
     if (raw === null)
         return fail('git-failed', `git could not read the commits in ${range}`);
     const records = raw.split('\0').filter((record) => record !== '');
     if (records.length === 0)
         return fail('no-commits', `no non-merge commits outside ${types_1.RECORD_DIR}/ in ${range}`);
     const commits = commitsFromRecords(records);
-    const derived = deriveFromCommits(commits);
+    // R3.3 amended: plan-only commits do not choose type or scope, so a second log over the same range drops docs/plans/.
+    const focusRaw = (0, git_1.runGit)(root, [...logArgs, EXCLUDE_PLANS]);
+    if (focusRaw === null)
+        return fail('git-failed', `git could not read the commits in ${range}`);
+    const focus = commitsFromRecords(focusRaw.split('\0').filter((record) => record !== ''));
+    const derived = deriveFromCommits(commits, focus);
     if (derived === null)
         return fail('no-conventional-commits', 'no commit in the range uses a conventional-commit subject (type(scope): subject)');
     const files = (0, git_1.changedFiles)(root, mergeBaseSha, head);

package/dist/src/core/changes/git.js

@@ -3,11 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_SAFETY_ARGS = void 0;
+exports.DEFAULT_BASES = exports.LOG_SAFETY_ARGS = void 0;
 exports.runGit = runGit;
 exports.runGitBytes = runGitBytes;
 exports.isSafeRef = isSafeRef;
 exports.isSafeRevision = isSafeRevision;
+exports.baseCandidates = baseCandidates;
 exports.resolveBaseCommit = resolveBaseCommit;
 exports.mergeBase = mergeBase;
 exports.isAncestor = isAncestor;
@@ -81,14 +82,44 @@ function isSafeRevision(rev) {
     return parts.length <= 2 && parts.every(isSafeRef);
 }
 /**
- * R3.1: --base, then origin/HEAD, then main, then master: the first that names a commit, with that commit's id. Null when none
- * does (or the explicit base is unsafe). One `rev-parse` per candidate.
+ * R3.1 (amended 2026-10-19): the default base candidates, remote first so a stale local branch is the last resort. The local
+ * branches resolve as full refs (git would otherwise prefer a tag `main` over the branch) but are reported by their short name.
+ */
+exports.DEFAULT_BASES = [
+    { ref: 'refs/remotes/origin/HEAD', name: 'refs/remotes/origin/HEAD' },
+    { ref: 'refs/remotes/origin/main', name: 'refs/remotes/origin/main' },
+    { ref: 'refs/remotes/origin/master', name: 'refs/remotes/origin/master' },
+    { ref: 'refs/heads/main', name: 'main' },
+    { ref: 'refs/heads/master', name: 'master' },
+];
+/**
+ * The DEFAULT_BASES whose exact ref exists, in order (one `for-each-ref` for all of them; a broken symref is not listed). Without
+ * this check git's rev-parse would fall through to `refs/tags/<ref>`, so a tag literally named `refs/heads/main` could stand in for
+ * an absent branch. The patterns are constants; only an exact refname match counts (a pattern also lists the refs below it).
+ * Empty when git fails: the defaults then fail closed as unresolved.
+ */
+function existingDefaultBases(root) {
+    const out = runGit(root, ['for-each-ref', '--format=%(refname)', '--end-of-options', ...exports.DEFAULT_BASES.map((c) => c.ref)]);
+    const present = new Set((out ?? '').split('\n'));
+    return exports.DEFAULT_BASES.filter((c) => present.has(c.ref));
+}
+/**
+ * R3.1: the candidates for a base, in order. An explicit base is the only one (no fallback) and keeps git's own resolution;
+ * otherwise the DEFAULT_BASES whose exact ref exists. Every caller (`resolveBaseCommit`, `resolveRange`) takes its order from here.
+ */
+function baseCandidates(root, explicit) {
+    return explicit !== undefined ? [{ ref: explicit, name: explicit }] : existingDefaultBases(root);
+}
+/**
+ * R3.1: --base, then origin/HEAD, origin/main, origin/master, main, master: the first that names a commit, with that commit's id.
+ * An explicit base is the only candidate (no fallback). Null when none does (or the explicit base is unsafe). One `rev-parse` per
+ * candidate tried (and, for the defaults, one `for-each-ref`).
  */
 function resolveBaseCommit(root, explicit) {
-    for (const candidate of explicit !== undefined ? [explicit] : ['refs/remotes/origin/HEAD', 'main', 'master']) {
-        const sha = commitSha(root, candidate);
+    for (const { ref, name } of baseCandidates(root, explicit)) {
+        const sha = commitSha(root, ref);
         if (sha !== null)
-            return { base: candidate, sha };
+            return { base: name, sha };
     }
     return null;
 }

package/dist/src/core/changes/range.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HEAD_MOVED = void 0;
+exports.HEAD_MOVED = exports.BASE_OPTION_HELP = void 0;
 exports.resolveBaseRef = resolveBaseRef;
 exports.resolveRange = resolveRange;
 exports.headMovedFailure = headMovedFailure;
@@ -9,34 +9,49 @@ const git_1 = require("./git");
 const text_safety_1 = require("./text-safety");
 const types_1 = require("./types");
 const REMEDY_BASE = 'pass --base <ref>';
+/** R3.1: the `--base` help text of `change new`, `change validate` and `changes list`: `DEFAULT_BASES` (git.ts) in order, remotes without `refs/remotes/`. */
+exports.BASE_OPTION_HELP = `base branch (default: ${git_1.DEFAULT_BASES.map((c) => c.name.replace(/^refs\/remotes\//, '')).join(', ')})`;
 exports.HEAD_MOVED = { code: 'head-moved', message: 'HEAD moved during derivation' };
 const KINDS = ['ok', 'absent', 'unsafe', 'error'];
 const failure = (code, message, remedy) => ({ ok: false, failure: remedy === undefined ? { code, message } : { code, message, remedy } });
+const unsafeBase = (explicitBase) => failure('invalid-input', `--base "${(0, text_safety_1.esc)(explicitBase)}" is not a safe git ref`);
 /**
- * R3.1/R3.2/R3.5: the base ref: `explicitBase` (checked with `isSafeRef` before git sees it: `invalid-input`), else origin/HEAD,
- * main, master; `base-unresolved` when none resolves. The one place that decides it, for `change new`, `change validate` and `changes list`.
+ * R3.1/R3.2/R3.5, for `changes list`: the base ref: `explicitBase` (checked with `isSafeRef` before git sees it: `invalid-input`),
+ * else the first default candidate that names a commit (no merge base is needed); `base-unresolved` when none does. The order of the
+ * candidates has one source, `baseCandidates` (git.ts), shared with `resolveRange`.
  */
 function resolveBaseRef(root, explicitBase) {
     if (explicitBase !== undefined && !(0, git_1.isSafeRef)(explicitBase))
-        return failure('invalid-input', `--base "${(0, text_safety_1.esc)(explicitBase)}" is not a safe git ref`);
+        return unsafeBase(explicitBase);
     const resolved = (0, git_1.resolveBaseCommit)(root, explicitBase);
     return resolved === null ? failure('base-unresolved', 'could not resolve a base branch', REMEDY_BASE) : { ok: true, ...resolved };
 }
 /**
- * R3.1/R3.2/R3.5: pins HEAD, then resolves the base (explicit `--base`, else origin/HEAD, main, master) and its merge base with HEAD.
- * An explicit base is checked with `isSafeRef` before git sees it.
+ * R3.1/R3.2/R3.5, for `change new` and `change validate`: pins HEAD, then resolves the base and its merge base with HEAD, over the
+ * same `baseCandidates` (git.ts) as `resolveBaseRef` but also requiring a merge base. An explicit `--base` (checked with `isSafeRef`
+ * before git sees it) is the only candidate. Without it (R3.1 amended, Q7), the first default candidate that names a commit AND has
+ * a merge base with HEAD: a shallow remote ref that does not reach HEAD gives way to the next.
+ * The merge base is computed from the commit id the candidate resolved to, never from its name read a second time (Q9).
  */
 function resolveRange(root, explicitBase) {
     const head = (0, git_1.headSha)(root);
     if (head === null)
         return failure('git-failed', 'git could not read HEAD');
-    const resolved = resolveBaseRef(root, explicitBase);
-    if (!resolved.ok)
-        return resolved;
-    const mergeBaseSha = (0, git_1.mergeBase)(root, resolved.base);
-    if (mergeBaseSha === null)
-        return failure('base-unresolved', `no merge base between "${(0, text_safety_1.esc)(resolved.base)}" and HEAD`, REMEDY_BASE);
-    return { ok: true, head, mergeBase: mergeBaseSha };
+    if (explicitBase !== undefined && !(0, git_1.isSafeRef)(explicitBase))
+        return unsafeBase(explicitBase);
+    let named = null;
+    for (const { ref, name } of (0, git_1.baseCandidates)(root, explicitBase)) {
+        const sha = (0, git_1.commitSha)(root, ref);
+        if (sha === null)
+            continue;
+        named ??= name;
+        const mergeBaseSha = (0, git_1.mergeBase)(root, sha);
+        if (mergeBaseSha !== null)
+            return { ok: true, head, mergeBase: mergeBaseSha };
+    }
+    if (named === null)
+        return failure('base-unresolved', 'could not resolve a base branch', REMEDY_BASE);
+    return failure('base-unresolved', `no merge base between "${(0, text_safety_1.esc)(named)}" and HEAD`, REMEDY_BASE);
 }
 /** `HEAD_MOVED` when HEAD is no longer `head` (or cannot be read), else null: a verdict about a moving target is never given. */
 function headMovedFailure(root, head) {

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/commands/change/new.test.js

@@ -781,7 +781,7 @@ describe('awm change new: base and derivation diagnostics (R3.1, R3.2, R3.5)', (
         receiptForHead();
         expectFailure(run('ok', { base: 'nope' }), 'base-unresolved', 'pass --base <ref>');
     });
-    test('no main, master or origin/HEAD is base-unresolved', () => {
+    test('no default base resolves: base-unresolved', () => {
         repo.git('branch', '-m', 'main', 'trunk');
         receiptForHead();
         expectFailure(run('ok'), 'base-unresolved', 'pass --base <ref>');
@@ -794,6 +794,29 @@ describe('awm change new: base and derivation diagnostics (R3.1, R3.2, R3.5)', (
         run('change-record', { base: 'mid' });
         expect(frontmatter(read())).toMatchObject({ type: 'fix', scope: 'core', semver: 'patch', modules: ['cli/src'] });
     });
+    test('a #228-shaped branch (plan commits first, then ci(release) commits) records type ci and scope release', () => {
+        repo.git('checkout', '-q', '-b', 'ci/shard', 'main');
+        repo.commit({ 'docs/plans/p.md': '1' }, 'docs(plans): plan it');
+        repo.commit({ '.github/workflows/ci.yml': '1' }, 'ci(release): shard');
+        repo.commit({ 'docs/plans/p.md': '2' }, 'docs(plans): amend A1');
+        repo.commit({ 'docs/plans/p.md': '3' }, 'docs(plans): amend A2');
+        repo.commit({ '.github/workflows/release.yml': '1' }, 'ci(release): gate it');
+        receiptForHead();
+        expect(run('change-record').code).toBe(0);
+        expect(frontmatter(read())).toMatchObject({ type: 'ci', scope: 'release', semver: 'none', breaking: false, modules: ['.github/workflows', 'docs/plans'] });
+    });
+    test('without origin/HEAD, a current origin/main is the base, not a stale local main', () => {
+        repo.git('checkout', '-q', '-b', 'upstream', 'main');
+        repo.commit({ 'other/u.ts': '1' }, 'feat(other)!: merged upstream');
+        repo.git('update-ref', 'refs/remotes/origin/main', 'upstream');
+        repo.git('checkout', '-q', '-b', 'feat/y', 'upstream');
+        repo.git('branch', '-D', 'upstream');
+        repo.commit({ 'cli/src/m.ts': '1' }, 'fix(core): mine');
+        receiptForHead();
+        expect(run('change-record').code).toBe(0);
+        // Against the stale local main, the upstream breaking feat would be in the range.
+        expect(frontmatter(read())).toMatchObject({ type: 'fix', scope: 'core', semver: 'patch', breaking: false, modules: ['cli/src'] });
+    });
     test('a branch with no commits beyond the base is no-commits', () => {
         repo.git('checkout', '-q', 'main');
         expectFailure(run('ok'), 'no-commits');
@@ -1096,6 +1119,10 @@ describe('registerChangeCommand', () => {
         const change = program().commands.find((c) => c.name() === 'change');
         const sub = change?.commands.find((c) => c.name() === 'new');
         expect(sub?.options.map((o) => o.long).sort()).toEqual(['--base', '--issue', '--model', '--plan', '--refresh', '--session']);
+        for (const name of ['new', 'validate']) {
+            const base = change?.commands.find((c) => c.name() === name)?.options.find((o) => o.long === '--base');
+            expect(base?.description).toBe('base branch (default: origin/HEAD, origin/main, origin/master, main, master)');
+        }
     });
     test('the change command describes both of its subcommands', () => {
         expect(program().commands.find((c) => c.name() === 'change')?.description()).toBe('create and validate the Change Record of the current branch');