agentic-workflow-manager 9.19.0 → 9.20.1

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REASON_GIT_FAILED = exports.REASON_NOT_REPO = exports.RUNTIME_STATE_EXCLUDES = void 0;
+exports.gitState = gitState;
+const path_1 = __importDefault(require("path"));
+const git_env_1 = require("./git-env");
+const text_safety_1 = require("./text-safety");
+/** Local runtime state that never counts as a working-tree change. Everything else under `.awm/` (e.g. `.awm/sensors.json`) does. */
+exports.RUNTIME_STATE_EXCLUDES = ['.awm/sensors/runs', '.awm/journal', '.awm/ledger', '.awm/evidence', '.awm/track.json'];
+exports.REASON_NOT_REPO = 'not inside a git repository with a commit';
+exports.REASON_GIT_FAILED = 'git command failed or timed out';
+const MAX_EXTRA_EXCLUDES = 64;
+const MAX_GIT_OUTPUT = 64 * 1024 * 1024;
+/** A git that ran and exited non-zero (no repo, no commit) is `not-repo`; one that could not run, timed out or overflowed is `failed`. */
+function gitFailure(error) {
+    return typeof error.status === 'number' ? { kind: 'not-repo' } : { kind: 'failed' };
+}
+/**
+ * Repository root, HEAD and whether the tree differs from it, excluding RUNTIME_STATE_EXCLUDES.
+ * `untracked` selects the pre-run measure (untracked files count, forced past any `status.showUntrackedFiles` config)
+ * or the post-run recheck (tracked changes only). `extraExcludes` (default none) are repo-relative paths ignored in addition
+ * to RUNTIME_STATE_EXCLUDES; any that is not a safe relative path makes the result `failed`. The root is returned with native
+ * separators: git prints forward slashes on Windows. Never throws.
+ */
+function gitState(cwd, untracked, extraExcludes = []) {
+    if (typeof cwd !== 'string' || cwd.length === 0)
+        return { kind: 'failed' };
+    if (!Array.isArray(extraExcludes) || extraExcludes.length > MAX_EXTRA_EXCLUDES || !extraExcludes.every(text_safety_1.isSafeRelativePath))
+        return { kind: 'failed' };
+    let root;
+    let commit;
+    try {
+        root = path_1.default.resolve((0, git_env_1.execGit)(cwd, ['rev-parse', '--show-toplevel'], { stderr: 'ignore' }).trim());
+        commit = (0, git_env_1.execGit)(root, ['rev-parse', 'HEAD'], { stderr: 'ignore' }).trim();
+    }
+    catch (error) {
+        return gitFailure(error);
+    }
+    try {
+        // Submodules are never hidden by config (`.gitmodules` ignore=all, diff.ignoreSubmodules). The pre-run measure counts everything
+        // (`none`); the post-run recheck is about tracked files only, so it also ignores untracked content inside a submodule
+        // (sensor build/coverage output) while still seeing a moved checkout or modified tracked content (`untracked`).
+        const args = ['status', '--porcelain', untracked ? '--untracked-files=normal' : '--untracked-files=no', untracked ? '--ignore-submodules=none' : '--ignore-submodules=untracked', '--', '.', ...exports.RUNTIME_STATE_EXCLUDES.map((p) => `:(exclude)${p}`), ...extraExcludes.map((p) => `:(exclude,literal)${p}`)];
+        const status = (0, git_env_1.execGit)(root, args, { stderr: 'ignore', maxBuffer: MAX_GIT_OUTPUT });
+        return { kind: 'ok', root, commit, dirty: status.trim().length > 0 };
+    }
+    catch {
+        return { kind: 'failed' };
+    }
+}

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

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROCESS_NAME = void 0;
 exports.parseProcessFrontmatter = parseProcessFrontmatter;
@@ -7,40 +10,155 @@ exports.parseProcessFrontmatter = parseProcessFrontmatter;
 // Disciplina heredada literal de core/orchestrators.ts: NUNCA lanza. Un modelo
 // malformado se rechaza con diagnóstico y no invalida al registry que lo
 // contiene ni a los demás (R7.1).
+const js_yaml_1 = __importDefault(require("js-yaml"));
 const frontmatter_1 = require("../frontmatter");
 const types_1 = require("./types");
 /** El discriminador es literal: ningún documento se reconoce como modelo por su
  *  cuerpo, sus headings ni su nombre de archivo (R1.2). */
 const DISCRIMINATOR = 'process-model';
-const ALLOWED_FIELDS = ['awm', 'schema', 'name', 'status', 'entry_point', 'terminates_to', 'created', 'updated'];
+/** `description` es el único campo opcional: runtimes como Codex se niegan a
+ *  cargar un `SKILL.md` sin él, y el modelo *es* el `SKILL.md` del skill. */
+const ALLOWED_FIELDS = ['awm', 'schema', 'name', 'status', 'entry_point', 'terminates_to', 'created', 'updated', 'description'];
+/** Límite de Agent Skills que imponen los runtimes que consumen el skill.
+ *  Se cuenta en code points, no en unidades UTF-16. */
+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). */
+const FRONTMATTER_MAX = 65536;
+/** 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
+ *  de TS es ES2022). */
+const FORBIDDEN_CHAR = /[\u0000-\u0008\u000A-\u001F\u007F-\u009F\u061C\u200E\u200F\u2028\u2029\u202A-\u202E\u2066-\u2069]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+/** 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$/;
 const STATUSES = ['draft', 'active'];
 /** El slug es lo único del modelo que puede viajar dentro de un id del Dashboard
  *  (ver sanitize.ts). Por eso se valida acá y no en la frontera de render: si
  *  admitiera rutas, markup o `=`, el id dejaría de ser seguro por construcción. */
 exports.PROCESS_NAME = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 const DATE = /^\d{4}-\d{2}-\d{2}$/;
+/** Caracteres de ancho cero: un valor hecho solo de ellos se ve vacío. */
+const ZERO_WIDTH = /[\u200B-\u200D\u2060\uFEFF]/g;
 /** Lector de pares `clave: valor` de un frontmatter plano. El contrato no admite
- *  anidamiento ni block scalars, así que no se arrastra un parser YAML: cualquier
- *  línea que no sea `clave: valor` es un rechazo, no una interpretación. */
+ *  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.) */
 function readPairs(block) {
     const pairs = new Map();
     const problems = [];
-    for (const raw of block.split(/\r?\n/)) {
-        const line = raw.trim();
+    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
+    // claves para un runtime) y solo se recorta espacio y tab (`\s`/`trim()`
+    // comerían NBSP o U+3000, que para YAML son contenido).
+    const lines = block.split(/\r\n|\r|\n/);
+    for (const [index, raw] of lines.entries()) {
+        const line = raw.replace(/^[ \t]+|[ \t]+$/g, '');
+        // 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 (line === '' || line.startsWith('#'))
             continue;
-        const m = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/.exec(line);
+        // El contrato es un mapa PLANO: una línea que empieza con espacio o tab
+        // es continuación de un valor multilínea, diga lo que diga. Si se
+        // recortara antes de mirar, `  KEY: x` pasaría por campo (y su nombre
+        // terminaría en un diagnóstico).
+        const indented = /^[ \t]/.test(raw);
+        if (indented)
+            continuations.push({ line: index + 1, text: line });
+        // `[\s\S]` y no `.`: un U+2028/U+2029 dentro del valor no lo vuelve
+        // "no-par" (la línea ya viene partida); lo rechaza el chequeo de controles.
+        const m = indented ? null : /^([A-Za-z_][A-Za-z0-9_]*)[ \t]*:[ \t]*([\s\S]*)$/.exec(line);
+        // Se reporta la POSICIÓN (1-based dentro del bloque), nunca el
+        // 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(`line is not a "key: value" pair: ${JSON.stringify(line.slice(0, 80))}`);
+            problems.push(`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])}`);
             continue;
         }
-        pairs.set(m[1], m[2].trim());
+        pairs.set(m[1], m[2]);
     }
-    return { pairs, problems };
+    return { pairs, problems, continuations };
+}
+/** 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`. */
+function loadBlock(block) {
+    if (block.length > FRONTMATTER_MAX)
+        return { kind: 'too-long' };
+    try {
+        return { kind: 'loaded', doc: js_yaml_1.default.load(block) };
+    }
+    catch {
+        return { kind: 'invalid' };
+    }
+}
+function isPlainObject(doc) {
+    return doc !== null && typeof doc === 'object' && Object.getPrototypeOf(doc) === Object.prototype;
+}
+/** Valida `description` leyéndola del bloque entero con el parser YAML real, no
+ *  de la salida de readPairs (ya recortada y partida en `:`, que difiere de lo
+ *  que lee un runtime). Ni el valor ni el texto del error de js-yaml (que puede
+ *  citar contenido) llegan al problema. */
+/** ¿El valor crudo de la línea, cargado SOLO, da el mismo string que el bloque
+ *  entero? Si no, YAML lo plegó con líneas siguientes (p. ej. una comilla que
+ *  sigue abierta a través de una línea `# …`). NUNCA lanza. */
+function readsSameAlone(raw, value) {
+    let alone;
+    try {
+        alone = js_yaml_1.default.load(`description: ${raw}`);
+    }
+    catch {
+        return false;
+    }
+    return isPlainObject(alone) && alone.description === value;
+}
+function checkDescription(raw, block, keys) {
+    const singleLine = { problem: '"description" must be a single-line string (block scalars are not supported in a process model)' };
+    // El prefijo alcanza: todo header de block scalar (bien o mal formado)
+    // empieza con `>` o `|`.
+    if (/^[>|]/.test(raw))
+        return singleLine;
+    const tooLong = { problem: `"description" must be at most ${DESCRIPTION_MAX} characters` };
+    const loaded = loadBlock(block);
+    if (loaded.kind === 'too-long')
+        return tooLong;
+    if (loaded.kind === 'invalid' || !isPlainObject(loaded.doc))
+        return { problem: '"description" cannot be read: the frontmatter is not valid YAML' };
+    const doc = loaded.doc;
+    // Si YAML lee otras claves de nivel superior que readPairs (un CR suelto,
+    // una comilla que se traga la línea siguiente), lo validado acá no es lo
+    // que verá un runtime. Ni claves ni valores van al problema.
+    const yamlKeys = Object.keys(doc);
+    if (yamlKeys.length !== keys.size || yamlKeys.some((k) => !keys.has(k))) {
+        return { problem: '"description" cannot be read: the frontmatter does not read the same as YAML (check quotes and line breaks)' };
+    }
+    const value = doc.description;
+    const empty = { problem: '"description" must not be empty' };
+    if (value === null || value === undefined)
+        return empty;
+    if (typeof value !== 'string') {
+        return { problem: '"description" must be a string (quote values YAML reads as a boolean, a number, a date or a collection)' };
+    }
+    if (value.replace(ZERO_WIDTH, '').trim() === '')
+        return empty;
+    if ([...value].length > DESCRIPTION_MAX)
+        return tooLong;
+    if (FORBIDDEN_CHAR.test(value))
+        return { problem: '"description" must not contain control, line-break or bidirectional-override characters' };
+    if (!readsSameAlone(raw, value))
+        return singleLine;
+    // Se guarda tal cual lo devuelve YAML: sin trim, con NBSP/BOM intactos.
+    return { value };
 }
 function parseProcessFrontmatter(source, file) {
     let block;
@@ -52,7 +170,22 @@ function parseProcessFrontmatter(source, file) {
     }
     if (block === null)
         return { diagnostics: [] };
-    const { pairs, problems } = readPairs(block);
+    const { pairs, problems, continuations } = readPairs(block);
+    // 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
+    // (sangría parcial o con tab; por encima del tope cuenta como no cargable)
+    // o carga con `awm: process-model` en su nivel superior. Si carga sin `awm`
+    // arriba (mención bajo `metadata:` o dentro de un block scalar), silencio.
+    if (!pairs.has('awm')) {
+        const indentedAwm = continuations.find((c) => INDENTED_DISCRIMINATOR.test(c.text));
+        const loaded = indentedAwm ? loadBlock(block) : undefined;
+        const fires = loaded !== undefined
+            && (loaded.kind !== 'loaded' || (isPlainObject(loaded.doc) && loaded.doc.awm === DISCRIMINATOR));
+        if (indentedAwm && fires) {
+            return { diagnostics: [`${file}: invalid process model — frontmatter keys must not be indented (frontmatter line ${indentedAwm.line})`] };
+        }
+    }
     // Sin discriminador NO es un modelo de proceso: no es un error, es otro
     // documento. Devolver diagnóstico acá inundaría de ruido a todo registry
     // (cada SKILL.md normal caería en esta rama).
@@ -96,6 +229,15 @@ function parseProcessFrontmatter(source, file) {
         if (value !== '' && !DATE.test(value))
             problems.push(`"${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);
+        else
+            description = checked.value;
+    }
     if (problems.length > 0) {
         return { diagnostics: [`${file}: invalid process model — ${problems.join('; ')}`] };
     }
@@ -103,6 +245,7 @@ function parseProcessFrontmatter(source, file) {
         model: {
             schema, name, status: status, entryPoint: entryPointRaw === 'true',
             terminatesTo, created: pairs.get('created'), updated: pairs.get('updated'),
+            ...(description !== undefined ? { description } : {}),
         },
         diagnostics: [],
     };

package/dist/src/index.js

@@ -45,6 +45,8 @@ const job_1 = require("./commands/job");
 const watch_1 = require("./commands/watch");
 const track_1 = require("./commands/track");
 const evidence_1 = require("./commands/evidence");
+const change_1 = require("./commands/change");
+const changes_1 = require("./commands/changes");
 const process_1 = require("./commands/process");
 const context_1 = require("./commands/context");
 const model_policy_1 = require("./commands/model-policy");
@@ -752,6 +754,8 @@ miroCmd.command('sync <storyMapPath>')
 (0, watch_1.registerWatchCommand)(exports.program);
 (0, track_1.registerTrackCommand)(exports.program);
 (0, evidence_1.registerEvidenceCommand)(exports.program);
+(0, change_1.registerChangeCommand)(exports.program);
+(0, changes_1.registerChangesCommand)(exports.program);
 (0, process_1.registerProcessCommand)(exports.program);
 (0, context_1.registerContextCommand)(exports.program);
 // Commander only waits for async action handlers through parseAsync().  The CLI has

package/dist/src/release/orchestrator.js

@@ -69,7 +69,9 @@ function release(opts, io) {
     const section = (0, core_1.renderChangelog)(version, io.today(), commits);
     io.writeChangelog(section + '\n' + io.readChangelog());
     io.run('git', ['add', 'cli/package.json', 'cli/package-lock.json', 'CHANGELOG.md']);
-    io.run('git', ['commit', '-m', `chore(release): v${version} [skip ci]`]);
+    // R6.1 (#217): the bump commit carries the Change Record opt-out trailer so
+    // `awm changes list` reports it as `exempt`, never as `missing`.
+    io.run('git', ['commit', '-m', `chore(release): v${version} [skip ci]`, '-m', 'Change-Record: none']);
     io.run('git', ['tag', '-a', `v${version}`, '-m', `v${version}`]);
     // OIDC mode: GitHub inyecta ACTIONS_ID_TOKEN_REQUEST_URL con id-token:write
     //            o NODE_AUTH_TOKEN sin NPM_TOKEN (setup-node legacy con OIDC)