agentic-workflow-manager 3.13.4 → 3.13.6

package/dist/src/core/diagnostics/provider-checks.js

@@ -17,19 +17,12 @@ exports.gatherProviderChecks = gatherProviderChecks;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../providers");
+const skill_integrity_1 = require("../skill-integrity");
 const provider_version_1 = require("../provider-version");
 const status_1 = require("../../commands/hooks/status");
 const orchestrator_1 = require("../context/orchestrator");
 const registries_1 = require("../registries");
-/** File extension a healthy AWM install actually produces for each non-`'link'` renderer —
- *  used by `skillsGlobalCheck` to require AWM-shaped evidence, not just an arbitrary
- *  non-empty directory (a user's own unrelated file in `~/.cursor/rules` would otherwise
- *  read as `'supported'`). Renderers absent from this map (i.e. `'link'`) never reach the
- *  branch that reads it. */
-const RENDERED_SKILL_EXTENSIONS = {
-    'cursor-mdc': '.mdc',
-    'copilot-instructions': '.instructions.md',
-};
+const registry_1 = require("../renderers/registry");
 /** Structural classification, computed purely from `provider`'s config shape — see
  *  `ProviderTier`'s doc comment in `types.ts` for what each tier means. */
 function providerTier(provider) {
@@ -66,7 +59,7 @@ function binaryVersionCheck(agent) {
  *  `dir` is null — i.e. the provider has no global skill discovery mechanism at all
  *  (today: Copilot, see `globalUnsupportedReason` in providers/index.ts).
  *
- *  `renderer` gates which verification is possible: `classifyGlobalSkills` (via `integrity`)
+ *  `renderer` gates which verification is possible: `classifySkillLinks` (via `integrity`)
  *  only ever sees symlinks — `if (!lst.isSymbolicLink()) continue;` — so for a rendered
  *  format (`cursor-mdc`, `copilot-instructions`) it scans a directory of real files and
  *  finds nothing, which would make `broken` silently read 0 regardless of whether the
@@ -87,7 +80,7 @@ function skillsGlobalCheck(dir, owners, integrity, renderer) {
             // `remediationCode: 'awm-init'` is a worse remedy than none, but this
             // check has no channel to report "can't tell" separately from "absent"
             // (same tradeoff already made by this file's agentsNativeCheck and by
-            // skill-integrity.ts's classifyGlobalSkills — a systemic, pre-existing
+            // skill-integrity.ts's classifySkillLinks — a systemic, pre-existing
             // pattern in this codebase, not introduced here).
             entries = [];
         }
@@ -97,7 +90,12 @@ function skillsGlobalCheck(dir, owners, integrity, renderer) {
         // Still not full integrity verification (a stray file with the right extension but
         // wrong content still passes) — that residual gap is the same honest tradeoff this
         // function's doc comment already accepts for the non-`'link'` branch generally.
-        const ext = RENDERED_SKILL_EXTENSIONS[renderer];
+        // `rendererExtension` (core/renderers/registry.ts) is the ONE table mapping a
+        // renderer to the file it produces. This site used to keep its own partial copy —
+        // the fourth such copy in the codebase, and the exact drift that made a rendered
+        // artifact invisible to the "is it installed" check for a whole release. A new
+        // renderer must not be able to be added without this reading it.
+        const ext = (0, registry_1.rendererExtension)(renderer);
         const present = ext ? entries.some((e) => e.endsWith(ext)) : entries.length > 0;
         return {
             id: 'skills.global',
@@ -165,20 +163,69 @@ function tomlAgentsHealthy(dir, entries) {
  * run (e.g. claude-code-only, opencode-only, antigravity-only) would always render
  * inapplicable rows as red ✖ and `overall` could never be 'healthy'.
  */
+/**
+ * Workflows installed at machine scope. Today only Antigravity declares a `workflow`
+ * config at all (`~/.gemini/antigravity/global_workflows`), and nothing verified it:
+ * `awm init` installed the baseline's workflows there and every diagnostic looked only
+ * at skills and native agents, so a broken or emptied workflow directory reported
+ * `healthy` forever on the one provider that uses it.
+ *
+ * Same N/A discipline as `agentsNativeCheck`: a provider with no workflow config, or a
+ * registry that ships no `workflows/`, emits NO row rather than a red one nobody can
+ * act on — an absent row means "nothing to verify", not "verified fine".
+ */
+function workflowsGlobalCheck(agent) {
+    const provider = (0, providers_1.providerFor)(agent);
+    if (!provider.workflow || provider.workflow.global === null)
+        return null;
+    const dir = provider.workflow.global;
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+    if (entries.length === 0)
+        return null;
+    // Los workflows se instalan con el renderer `link`, asi que un symlink colgante es
+    // exactamente la misma clase de rotura que en skills — y se clasifica con la misma
+    // funcion, no con una copia local que pueda divergir.
+    const integrity = (0, skill_integrity_1.classifySkillLinks)(dir, (0, registries_1.contentRoots)());
+    const broken = integrity.repairable.length + integrity.dead.length;
+    return {
+        id: 'workflows.global',
+        state: broken > 0 ? 'broken' : 'healthy',
+        target: dir,
+        detail: broken > 0 ? `${broken} broken link(s)` : undefined,
+        remediationCode: broken > 0 ? 'awm-init' : undefined,
+    };
+}
 function agentsNativeCheck(agent) {
     const provider = (0, providers_1.providerFor)(agent);
     if (!provider.agent || provider.agent.global === null)
         return null;
     const dir = provider.agent.global;
     let entries;
+    // `absent` degrada el estado global, asi que sin `remediationCode` doctor
+    // salia 1 sin decir que hacer — y para un registry que simplemente no trae
+    // `agents/` (lo normal) ese rojo no tiene accion posible. Se reporta como
+    // `unsupported`, que describe la realidad: no hay artefactos nativos que
+    // verificar, y no es culpa de la instalacion.
+    // Un registry que simplemente no trae `agents/` es lo normal, no un defecto
+    // de la instalacion — y no hay accion que el usuario pueda tomar. Antes esto
+    // devolvia `absent`, un estado que DEGRADA, y sin `remediationCode`: doctor
+    // salia 1 mostrando `✖ native agents` sin decir que hacer, justo despues de
+    // un `awm init` exitoso. Cuando no hay nada nativo que verificar, no se
+    // emite fila — el mismo criterio que ya usan los demas casos N/A de aca.
     try {
         entries = fs_1.default.readdirSync(dir);
     }
     catch {
-        return { id: 'agents.native', state: 'absent', target: dir };
+        return null;
     }
     if (entries.length === 0)
-        return { id: 'agents.native', state: 'absent', target: dir };
+        return null;
     if (provider.agent.renderer === 'codex-agent-toml') {
         const { broken } = tomlAgentsHealthy(dir, entries);
         return {
@@ -292,6 +339,7 @@ function gatherProviderChecks(agents, scanSkills, projectRoot) {
             binaryVersionCheck(agent),
             skillsGlobalCheck(dir, owners, integrity, provider.skill.renderer),
             agentsNativeCheck(agent),
+            workflowsGlobalCheck(agent),
             hookTrustCheck(agent),
             contextGlobalCheck(agent, projectRoot),
         ].filter((check) => check !== null);

package/dist/src/core/discovery.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchFrontmatterBlock = matchFrontmatterBlock;
+exports.findFrontmatterDescription = exports.isBlockScalarHeader = exports.readFrontmatterDescription = exports.matchFrontmatterBlock = void 0;
 exports.readArtifactDescription = readArtifactDescription;
 exports.discoverSkills = discoverSkills;
 exports.discoverWorkflows = discoverWorkflows;
@@ -12,31 +12,23 @@ exports.discoverAgents = discoverAgents;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const registries_1 = require("./registries");
-/** Extracts the raw frontmatter text (between the --- delimiters), or null if the block is missing/malformed. CRLF-tolerant. */
-function matchFrontmatterBlock(raw) {
-    const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    return fmMatch ? fmMatch[1] : null;
-}
+// El parseo de frontmatter vive en el modulo HOJA `core/frontmatter.ts`
+// (sin imports, para que consumidores puros como export/transform.ts no
+// arrastren fs/git por transitividad). Se re-exporta aca porque este modulo
+// ya era el punto de entrada historico para esos helpers.
+var frontmatter_1 = require("./frontmatter");
+Object.defineProperty(exports, "matchFrontmatterBlock", { enumerable: true, get: function () { return frontmatter_1.matchFrontmatterBlock; } });
+Object.defineProperty(exports, "readFrontmatterDescription", { enumerable: true, get: function () { return frontmatter_1.readFrontmatterDescription; } });
+Object.defineProperty(exports, "isBlockScalarHeader", { enumerable: true, get: function () { return frontmatter_1.isBlockScalarHeader; } });
+Object.defineProperty(exports, "findFrontmatterDescription", { enumerable: true, get: function () { return frontmatter_1.findFrontmatterDescription; } });
+const frontmatter_2 = require("./frontmatter");
 function readArtifactDescription(filePath) {
     try {
         const raw = fs_1.default.readFileSync(filePath, 'utf-8');
-        const frontmatter = matchFrontmatterBlock(raw);
+        const frontmatter = (0, frontmatter_2.matchFrontmatterBlock)(raw);
         if (frontmatter === null)
             return '';
-        const line = frontmatter
-            .split(/\r?\n/)
-            .find((l) => /^description\s*:/.test(l));
-        if (!line)
-            return '';
-        let val = line.replace(/^description\s*:/, '').trim();
-        if ((val.startsWith('"') && val.endsWith('"')) ||
-            (val.startsWith("'") && val.endsWith("'"))) {
-            val = val.slice(1, -1);
-        }
-        const BLOCK_INDICATORS = new Set(['>-', '>', '|-', '|', '>+', '|+']);
-        if (BLOCK_INDICATORS.has(val.trim()))
-            return '';
-        return val.trim();
+        return (0, frontmatter_2.readFrontmatterDescription)(frontmatter);
     }
     catch {
         return '';
@@ -102,7 +94,7 @@ function discoverWorkflows(roots = (0, registries_1.contentRoots)()) {
         for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
             if (entry.isDirectory() || !entry.name.endsWith('.md'))
                 continue;
-            const name = entry.name.replace('.md', '');
+            const name = entry.name.replace(/\.md$/, '');
             const filePath = path_1.default.join(dir, entry.name);
             mergeEntry('workflow', byName, {
                 name,
@@ -128,7 +120,7 @@ function discoverAgents(roots = (0, registries_1.contentRoots)()) {
         for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
             if (entry.isDirectory() || !entry.name.endsWith('.md'))
                 continue;
-            const name = entry.name.replace('.md', '');
+            const name = entry.name.replace(/\.md$/, '');
             const filePath = path_1.default.join(dir, entry.name);
             mergeEntry('agent', byName, {
                 name,

package/dist/src/core/export/transform.js

@@ -7,7 +7,10 @@ exports.claudeAiTransform = claudeAiTransform;
 //
 // Transform mecánico claude.ai (R3.1): función pura string → string.
 // Frontmatter line-based plano (los SKILL.md del baseline usan claves de una
-// línea) — sin parser YAML a propósito (YAGNI, cero deps).
+// línea) — sin parser YAML a propósito (YAGNI, cero deps). La única forma
+// multilínea soportada es el block scalar de `description:`, resuelto vía la
+// función compartida de discovery.ts (ver claudeAiTransform).
+const frontmatter_1 = require("../frontmatter");
 const DEFERENCE_LINE = (skillName) => `In environments with AWM installed (Claude Code), defer to the registry's ${skillName} skill — this port is for environments without filesystem access.`;
 exports.DEFERENCE_LINE = DEFERENCE_LINE;
 // Paths intra-registry: resuelven en Claude Code (donde el registry está en
@@ -73,34 +76,36 @@ function claudeAiTransform(skillMd, skillName) {
     const body = skillMd.slice(end + endMatch[0].length);
     const fmLines = skillMd.slice(startLen, end).split(/\r?\n/)
         .filter((l) => !/^(version|portable):/.test(l));
-    const descIdx = fmLines.findIndex((l) => /^description:/.test(l));
-    if (descIdx === -1) {
+    // UN SOLO camino para todas las formas de `description`. Antes habia uno por
+    // forma (plano / entrecomillado / bloque) y cada vez que el LECTOR aprendia
+    // una forma nueva, el ESCRITOR de aca quedaba atras — la divergencia exacta
+    // que este modulo dice cerrar. Casos reales que produjo esa asimetria:
+    //  - escalar plano multilinea: la deference line se insertaba en la primera
+    //    linea y la continuacion quedaba huerfana debajo, o sea la frase de
+    //    deference terminaba enterrada en el medio de la descripcion;
+    //  - escalar plano con ` # comentario` final: la deference line se anexaba
+    //    DESPUES del `#`, o sea YAML se la comia entera como comentario y el
+    //    artefacto exportado perdia en silencio la unica frase que este
+    //    transform existe para agregar.
+    // Ahora se resuelve el campo con la funcion compartida, se reemplaza su
+    // extension COMPLETA (startLine..endLine) y se emite siempre un escalar
+    // double-quoted via JSON.stringify — superset valido de YAML que cubre
+    // comillas, `:`, `#` y los `\n` de un literal `|` sin decidir estilo.
+    const field = (0, frontmatter_1.findFrontmatterDescription)(fmLines.join('\n'));
+    if (field.startLine === -1) {
         throw new Error('frontmatter has no description field');
     }
-    const descLine = fmLines[descIdx];
-    const value = descLine.slice('description:'.length).trim();
-    if (value === '' || value === '>' || value === '|' || value.startsWith('>') || value.startsWith('|')) {
-        throw new Error('description must be single-line (block scalars are not supported by the export transform)');
+    const rawValue = fmLines[field.startLine].replace(/^description\s*:/, '').trim();
+    // Empieza con `>`/`|` pero no es un indicador bien formado (ej. `>-basura`):
+    // YAML mismo lo rechaza. Fallar explicito en vez de publicar basura.
+    if (/^[>|]/.test(rawValue) && !(0, frontmatter_1.isBlockScalarHeader)(rawValue)) {
+        throw new Error(`malformed block scalar indicator in description: ${rawValue}`);
     }
-    const deference = (0, exports.DEFERENCE_LINE)(skillName);
-    // Quote-style detection mirrors readArtifactDescription in discovery.ts: both
-    // single- and double-quoted scalars are first-class, and we work off the
-    // trimmed value so trailing whitespace after a closing quote doesn't fool us.
-    const isDoubleQuoted = value.length >= 2 && value.startsWith('"') && value.endsWith('"');
-    const isSingleQuoted = value.length >= 2 && value.startsWith("'") && value.endsWith("'");
-    if ((value.startsWith('"') || value.startsWith("'")) && !isDoubleQuoted && !isSingleQuoted) {
-        throw new Error('description has trailing content after its closing quote (e.g. an inline comment) — not supported by the export transform; remove the comment or use a port.claude-ai.md override');
+    if (!field.value) {
+        throw new Error((0, frontmatter_1.isBlockScalarHeader)(rawValue) ? 'description block scalar has no content' : 'description is empty');
     }
-    // YAML single-quoted scalars escape a literal ' by doubling it (''); the
-    // deference text ("...registry's..." — see DEFERENCE_LINE) contains an
-    // apostrophe, so it must be escaped before splicing into a single-quoted
-    // description or it would prematurely close the YAML string.
-    const newValue = isDoubleQuoted
-        ? `${value.slice(0, -1)} ${deference}"`
-        : isSingleQuoted
-            ? `${value.slice(0, -1)} ${deference.replace(/'/g, "''")}'`
-            : `${value} ${deference}`;
-    fmLines[descIdx] = `description: ${newValue}`;
+    const merged = JSON.stringify(`${field.value} ${(0, exports.DEFERENCE_LINE)(skillName)}`);
+    fmLines.splice(field.startLine, field.endLine - field.startLine + 1, `description: ${merged}`);
     // Solo el body: el frontmatter ya se editó arriba y sus campos no son prosa
     // navegable (R2.4).
     return `---\n${fmLines.join('\n')}\n---\n${stripIntraRegistryPaths(body)}`;

package/dist/src/core/frontmatter.js

@@ -0,0 +1,223 @@
+"use strict";
+// src/core/frontmatter.ts
+//
+// Modulo HOJA: sin imports. Es la unica fuente de verdad para leer el
+// frontmatter YAML de un artefacto (SKILL.md, agents/*.md, workflows/*.md).
+//
+// Por que hoja: sus consumidores incluyen `core/export/transform.ts`, que se
+// documenta como funcion pura string -> string sin dependencias. Si esto
+// viviera en `discovery.ts` (que importa `registries.ts`, y este a su vez
+// resuelve `awmHome()` y carga `simple-git` en tiempo de import), un modulo
+// puro terminaria arrastrando la capa de fs/git por transitividad.
+//
+// Por que existe: el frontmatter se parseaba a mano en CUATRO lugares, cada
+// uno con su propia copia incompleta. Un block scalar YAML valido
+// (`description: >-`, con el texto en las lineas indentadas siguientes)
+// degradaba en silencio en discovery, crasheaba `awm add -a cursor|copilot`,
+// abortaba `awm export <bundle>` entero y rompia `awm add -a codex`. La
+// semantica de aca se verifica contra js-yaml (parser real) en
+// tests/core/frontmatter-description-vs-yaml.test.ts — no contra valores
+// esperados escritos a mano, que pueden envejecer hacia la expectativa
+// equivocada.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchFrontmatterBlock = matchFrontmatterBlock;
+exports.isBlockScalarHeader = isBlockScalarHeader;
+exports.findFrontmatterDescription = findFrontmatterDescription;
+exports.readFrontmatterDescription = readFrontmatterDescription;
+/** Texto crudo del frontmatter (entre los delimitadores `---`), o null si el
+ *  bloque falta o esta mal formado. Tolera CRLF. */
+function matchFrontmatterBlock(raw) {
+    const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    return fmMatch ? fmMatch[1] : null;
+}
+/** Indicador de block scalar en la linea de la clave: estilo (`>` folded /
+ *  `|` literal) + chomping opcional (`-`/`+`) + indentacion explicita opcional
+ *  + comentario final opcional. Detalles verificados contra js-yaml:
+ *   - la indentacion explicita es UN digito 1-9 (ni `0` ni `10`);
+ *   - `>- # nota` es valido y su bloque se lee normal;
+ *   - `>-basura` NO es valido y aca tampoco matchea. */
+const BLOCK_SCALAR_HEADER = /^([>|])(?:([+-])?([1-9])?|([1-9])?([+-])?)(?:\s+#.*)?$/;
+/** ¿El valor de la linea de la clave es un indicador de block scalar?
+ *  Cualquier caller que RAMIFIQUE sobre "esto es un bloque" debe usar esta
+ *  funcion, nunca una aproximacion propia: una guarda por prefijo (`/^[>|]/`)
+ *  y un resolver por match completo se desincronizan, y en ese hueco el
+ *  escritor borro contenido real creyendo que resolvia un bloque. */
+function isBlockScalarHeader(value) {
+    return BLOCK_SCALAR_HEADER.test(value.trim());
+}
+/** Indice de la comilla que CIERRA el escalar que empieza en la posicion 0, o
+ *  -1 si no cierra. Cada estilo escapa distinto: en single-quoted un `''` es
+ *  un apostrofe literal (no un cierre); en double-quoted un `\"` es una
+ *  comilla literal. */
+function findClosingQuote(value, quote) {
+    for (let i = 1; i < value.length; i++) {
+        if (quote === '"' && value[i] === '\\') {
+            i++;
+            continue;
+        }
+        if (value[i] !== quote)
+            continue;
+        if (quote === "'" && value[i + 1] === "'") {
+            i++;
+            continue;
+        }
+        return i;
+    }
+    return -1;
+}
+function foldBlock(stripped, isLiteral) {
+    if (isLiteral)
+        return stripped.join('\n').trim();
+    // Folded (`>`): las lineas al nivel base del bloque se pliegan entre si con
+    // UN espacio; una linea MAS indentada no se pliega (conserva su salto y su
+    // sangria — la regla que permite incrustar una lista dentro de un folded);
+    // y k lineas en blanco consecutivas producen k saltos de linea.
+    // Ojo: NO se hace trim por linea — YAML conserva los espacios finales de
+    // cada linea y el plegado agrega el suyo encima.
+    let out = '';
+    let prevLiteral = false;
+    let started = false;
+    let blanks = 0;
+    for (const line of stripped) {
+        if (line === '') {
+            blanks++;
+            continue;
+        }
+        const literal = /^[ \t]/.test(line);
+        if (!started) {
+            out = line;
+            started = true;
+            prevLiteral = literal;
+            blanks = 0;
+            continue;
+        }
+        if (blanks > 0) {
+            out += '\n'.repeat(blanks);
+            blanks = 0;
+        }
+        else if (literal || prevLiteral)
+            out += '\n';
+        else
+            out += ' ';
+        out += line;
+        prevLiteral = literal;
+    }
+    return out.trim();
+}
+/**
+ * Localiza y RESUELVE el campo `description` de un bloque de frontmatter,
+ * devolviendo tambien la extension exacta que ocupa (para que un escritor
+ * pueda reemplazarlo entero).
+ *
+ * Formas soportadas, todas contrastadas contra js-yaml: escalar plano (de una
+ * o varias lineas), escalar entrecomillado (simple y doble, con su escape
+ * propio deshecho), y block scalar folded/literal con chomping e indentacion
+ * explicita.
+ */
+function findFrontmatterDescription(frontmatter) {
+    const lines = frontmatter.split(/\r?\n/);
+    // Ancla en COLUMNA 0 a proposito: `description` en un frontmatter es
+    // siempre clave de nivel superior. Un `^\s*` haria ganar a un
+    // `description:` INDENTADO — anidado en otro mapa, o una linea de
+    // CONTENIDO de otro block scalar que casualmente empiece asi.
+    const startLine = lines.findIndex((l) => /^description\s*:/.test(l));
+    if (startLine === -1)
+        return { value: '', startLine: -1, endLine: -1 };
+    const raw = lines[startLine].replace(/^description\s*:/, '').trim();
+    if (isBlockScalarHeader(raw)) {
+        const isLiteral = raw.trim().startsWith('|');
+        // El bloque son las lineas ESTRICTAMENTE indentadas respecto de la
+        // clave (columna 0). Las lineas en blanco no lo cortan: pertenecen a el.
+        const block = [];
+        let last = startLine;
+        for (let i = startLine + 1; i < lines.length; i++) {
+            if (lines[i].trim() === '') {
+                block.push(lines[i]);
+                continue;
+            }
+            if (!/^[ \t]/.test(lines[i]))
+                break;
+            block.push(lines[i]);
+            last = i;
+        }
+        while (block.length > 0 && block[block.length - 1].trim() === '')
+            block.pop();
+        const first = block.find((l) => l.trim() !== '');
+        if (first === undefined)
+            return { value: '', startLine, endLine: startLine };
+        const declared = raw.match(/[1-9]/);
+        const blockIndent = declared !== null ? Number(declared[0]) : first.match(/^[ \t]*/)[0].length;
+        // Una linea con MENOS indentacion que el bloque es YAML invalido
+        // (js-yaml lanza "bad indentation"). Cortar a ciegas con slice()
+        // comeria caracteres reales: preferimos no inventar un valor.
+        if (block.some((l) => l.trim() !== '' && l.match(/^[ \t]*/)[0].length < blockIndent)) {
+            return { value: '', startLine, endLine: last };
+        }
+        const stripped = block.map((l) => l.slice(blockIndent));
+        return { value: foldBlock(stripped, isLiteral), startLine, endLine: last };
+    }
+    // Empieza con `>`/`|` pero NO es un indicador bien formado (`>0`, `>12`,
+    // `>-basura`): YAML lo rechaza. Devolver '' hace que los consumidores
+    // fallen fuerte (throw en parseSkillSource / claudeAiTransform) en vez de
+    // caer al camino de escalar plano de abajo, que publicaria el indicador
+    // mismo como si fuera la descripcion.
+    if (/^[>|]/.test(raw))
+        return { value: '', startLine, endLine: startLine };
+    // Continuacion multilinea. Aplica a DOS formas, y ambas la necesitan:
+    //  - escalar plano (`description: primera` + lineas indentadas), que YAML
+    //    pliega con espacios igual que un `>`;
+    //  - escalar ENTRECOMILLADO cuya comilla de cierre esta en una linea
+    //    posterior (`description: "hola` / `  mundo"`), que sin esto devolvia
+    //    `"hola` — con la comilla de apertura pegada — como descripcion.
+    // Sin juntar las lineas primero, del lado escritor ademas quedaban
+    // huerfanas en la salida exportada.
+    let endLine = startLine;
+    let value = raw;
+    const opensUnclosedQuote = /^['"]/.test(raw) && findClosingQuote(raw, raw[0]) === -1;
+    if (raw !== '' && (!/^['"]/.test(raw) || opensUnclosedQuote)) {
+        const cont = [];
+        for (let i = startLine + 1; i < lines.length; i++) {
+            if (lines[i].trim() === '')
+                break;
+            if (!/^[ \t]/.test(lines[i]))
+                break;
+            cont.push(lines[i].trim());
+            endLine = i;
+        }
+        if (cont.length > 0)
+            value = [raw, ...cont].join(' ');
+    }
+    // Escalares entrecomillados. Dos cosas que no alcanzan por separado:
+    //  1. Hay que ENCONTRAR la comilla de cierre real antes de mirar el resto:
+    //     lo que sigue a esa comilla es un comentario, no parte del valor.
+    //     Comparar con `endsWith` fallaba justo cuando habia comentario
+    //     (`description: "x" # nota` devolvia `"x"` CON las comillas literales,
+    //     mientras js-yaml devuelve `x`).
+    //  2. Hay que deshacer el escape propio de cada estilo: single-quoted
+    //     duplica el apostrofe (`''`); double-quoted es superset de la string
+    //     JSON, asi que JSON.parse resuelve \n, \t, \", \\ y \uXXXX.
+    const quote = value[0];
+    if (quote === "'" || quote === '"') {
+        const close = findClosingQuote(value, quote);
+        if (close !== -1) {
+            const scalar = value.slice(0, close + 1);
+            if (quote === "'") {
+                return { value: scalar.slice(1, -1).replace(/''/g, "'").trim(), startLine, endLine };
+            }
+            try {
+                return { value: String(JSON.parse(scalar)).trim(), startLine, endLine };
+            }
+            catch {
+                return { value: scalar.slice(1, -1).trim(), startLine, endLine };
+            }
+        }
+    }
+    // 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
+    // comillas el `#` es literal, y esas ramas ya retornaron.
+    return { value: value.replace(/\s+#.*$/, '').trim(), startLine, endLine };
+}
+/** Azucar para el caso comun: solo el valor resuelto de `description`. */
+function readFrontmatterDescription(frontmatter) {
+    return findFrontmatterDescription(frontmatter).value;
+}

package/dist/src/core/init/mutation-targets.js

@@ -110,6 +110,17 @@ function planInitMutationTargets(params) {
     for (const b of machineBundles) {
         addBundleTargets(targets, b.name, bundles, agent, 'global', cwd, contentDir);
     }
+    // Providers whose context injection is itself project-scope (managed-agents-md
+    // with a null globalPath — Cursor, Copilot) write AGENTS.md and the materialized
+    // .awm/context/ file. `stepContextInjection` now refuses to write those without a
+    // discovered project root, but enumerating them against `cwd` unconditionally
+    // costs nothing (a target that goes unwritten is a no-op backup entry, per this
+    // module's opening note) and keeps the guarantee from resting on a single site:
+    // under-enumeration here is the one failure mode that silently defeats rollback.
+    if (injection?.type === 'managed-agents-md' && injection.globalPath === null) {
+        targets.add(path_1.default.join(cwd, path_1.default.basename(injection.localFile)));
+        targets.add((0, materializer_1.projectContextPath)(cwd));
+    }
     // project-level: profile, sensors manifest, project injection, and every
     // extension currently recorded in .awm/profile.json
     const projectRoot = (0, profile_1.findProjectRoot)(cwd);