agentic-workflow-manager 3.13.3 → 3.13.5

package/dist/src/core/diagnostics/context.js

@@ -112,19 +112,33 @@ function gatherMachine(bundles, agent = 'claude-code') {
     }
     catch { /* sin soporte de hooks → ausente */ }
     // devCore (bundle baseline) — skillsDir is null only for providers with no global skill
-    // discovery mechanism (today: Copilot); treated the same as "nothing linked here yet".
+    // discovery mechanism (today: Copilot); for those, there is no global-scope devCore
+    // concept to satisfy at all, so it's treated as trivially satisfied (see below).
     const skillsDir = (0, providers_1.providerFor)(agent).skill.global;
     const baseline = bundles.find((b) => b.scope === 'baseline');
     let devCorePresent = false;
     let brokenLinks = [];
     if (baseline) {
         const skillNames = (0, bundles_1.resolveBundleSkills)(baseline.name, bundles);
-        const { linked, broken } = skillsDir !== null
-            ? classifyLinks(skillNames, skillsDir)
-            : { linked: [], broken: [] };
-        const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
-        devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
-        brokenLinks = [...broken, ...absent];
+        if (skillsDir === null) {
+            // No global skill directory for this agent (today: Copilot) — there is no
+            // global-scope devCore/baseline-bundle concept to satisfy for it at all, so
+            // "N/A" is reported as satisfied (present, nothing broken) rather than
+            // "missing". Mirrors globalSkills' treatment just below (empty valid/
+            // repairable/dead when skillsDir === null). Without this, devCorePresent
+            // was unconditionally false here (linked/broken forced to empty arrays),
+            // so `machine.devCore` could never be satisfied for Copilot — stepDevCore
+            // (init/steps.ts) would fall through on every run and call installBundle at
+            // global scope, which throws (skill.global === null), rolling back the
+            // ENTIRE `awm init -a copilot` transaction, 100% of the time.
+            devCorePresent = true;
+        }
+        else {
+            const { linked, broken } = classifyLinks(skillNames, skillsDir);
+            const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
+            devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
+            brokenLinks = [...broken, ...absent];
+        }
         // Agent-type artifacts are never shared across agents (R12/R13 —
         // install-planner.ts — unlike skills, where OpenCode and Codex both
         // resolve to ~/.agents/skills). A shared skill directory already
@@ -155,9 +169,19 @@ function gatherMachine(bundles, agent = 'claude-code') {
         }
     }
     catch { /* sin config → ningún ambient deseado */ }
-    const installed = wanted.filter((name) => {
+    // Same guard as devCorePresent above: an agent with no global skill
+    // directory (today: Copilot) has no way to ever receive a globally-
+    // installed ambient bundle either — there is no global-scope "ambient"
+    // concept to satisfy for it at all. Without this, `installed` was forced
+    // to `[]` unconditionally for Copilot regardless of `wanted`, so
+    // stepAmbient (init/steps.ts) would treat every entry of a machine-level
+    // `~/.awm/config.json`'s `ambient` array as permanently missing and call
+    // installBundle at global scope — which throws for Copilot exactly like
+    // the devCore bug this file already fixes. Reported as "N/A == already
+    // satisfied" (installed), not "wanted but always missing".
+    const installed = skillsDir === null ? [...wanted] : wanted.filter((name) => {
         const skillNames = (0, bundles_1.resolveBundleSkills)(name, bundles);
-        if (skillNames.length === 0 || skillsDir === null)
+        if (skillNames.length === 0)
             return false;
         const { linked } = classifyLinks(skillNames, skillsDir);
         return linked.length === skillNames.length;

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 '';

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/journal/process.js

@@ -298,11 +298,28 @@ function sleepMsSync(ms) {
  *  con una pausa breve ANTES de declarar ESRCH definitivo no debilita el
  *  invariante "jamas muerte sin evidencia" — un proceso genuinamente muerto
  *  sigue reportando ESRCH en el reintento; esto solo absorbe el falso
- *  negativo transitorio. Costo maximo: ~150ms, y SOLO en la rama que ya iba
- *  a declarar "no existe" — el camino feliz (proceso vivo, exito inmediato)
- *  no paga nada. */
-const PID_EXISTS_RETRY_ATTEMPTS = 3;
-const PID_EXISTS_RETRY_DELAY_MS = 50;
+ *  negativo transitorio. Costo maximo, y SOLO en la rama que ya iba a
+ *  declarar "no existe" — el camino feliz (proceso vivo, exito inmediato)
+ *  no paga nada.
+ *
+ *  R6 post-mortem #2: el presupuesto original (3 intentos, 50ms => 100ms de
+ *  espera real) sobrevivio 2 corridas reales de windows-latest tras mergear
+ *  este mismo mecanismo, pero una tercera corrida real (commit identico,
+ *  ningun cambio en este archivo) volvio a fallar EL MISMO assert en EL
+ *  MISMO test — siempre el PRIMER spawn del archivo, nunca los siguientes
+ *  (que reusan un binario node.exe ya "calentado" por el SO/AV en ese
+ *  proceso de test). Eso apunta a latencia de arranque en frio (primer
+ *  spawn del job) empujando el tiempo de visibilidad de OpenProcess mas
+ *  alla del presupuesto anterior — no una condicion de carrera nueva, la
+ *  MISMA, con cola mas larga de lo que 100ms cubria. Presupuesto ampliado a
+ *  10 intentos / 100ms (hasta ~900ms de espera real) para darle margen real
+ *  a ese arranque en frio, siguiendo cuestionando el mismo mecanismo en vez
+ *  de reemplazarlo (systematic-debugging: 2+ fallas del mismo sintoma exacto
+ *  primero exige ampliar el mismo remedio antes de descartar la arquitectura
+ *  — a diferencia del patron de "cada intento revela un problema nuevo en
+ *  otro lugar", que si justificaria cuestionar el diseño). */
+const PID_EXISTS_RETRY_ATTEMPTS = 10;
+const PID_EXISTS_RETRY_DELAY_MS = 100;
 function pidExistsNative(pid) {
     for (let attempt = 0; attempt < PID_EXISTS_RETRY_ATTEMPTS; attempt++) {
         try {

package/dist/src/core/renderers/canonical-agent.js

@@ -1,21 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCanonicalAgent = parseCanonicalAgent;
+const frontmatter_1 = require("../frontmatter");
 function parseCanonicalAgent(source) {
     const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
     if (!match)
         throw new Error('canonical agent requires YAML frontmatter');
     const fields = new Map();
-    for (const line of match[1].split(/\r?\n/)) {
+    // La validacion linea-por-linea sigue siendo estricta a proposito (atrapa
+    // frontmatter malformado), pero debe reconocer los block scalars: sus
+    // lineas de CONTENIDO estan indentadas y no son pares `clave: valor`.
+    // Antes lanzaban "invalid canonical agent frontmatter line", asi que un
+    // agente con `description: >-` rompia `awm add <x> -a codex`. Peor aun
+    // tras unificar el discovery: el picker mostraba la descripcion bien
+    // resuelta y recien despues explotaba el install — dos caminos leyendo el
+    // MISMO archivo con reglas distintas.
+    const lines = match[1].split(/\r?\n/);
+    let sawKey = false;
+    for (const line of lines) {
+        // Toda linea INDENTADA (o en blanco) es continuacion del valor de la
+        // clave anterior, no una clave nueva: asi se ven tanto el contenido de
+        // un block scalar como el de un escalar plano multilinea, y ambos son
+        // YAML valido. El primer fix de esto solo contemplo el block scalar,
+        // asi que `description: primera\n  continuacion` seguia lanzando
+        // "invalid canonical agent frontmatter line" y rompiendo
+        // `awm add -a codex` — mientras discovery, leyendo el MISMO archivo con
+        // la funcion compartida, mostraba la descripcion correcta en el picker.
+        // Dos caminos sobre el mismo archivo o se arreglan juntos o divergen de
+        // una forma mas confusa que el bug original.
+        if (sawKey && (line.trim() === '' || /^[ \t]/.test(line)))
+            continue;
         const field = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
         if (!field)
             throw new Error(`invalid canonical agent frontmatter line: ${line}`);
         if (fields.has(field[1]))
             throw new Error(`duplicate canonical agent frontmatter key: ${field[1]}`);
+        sawKey = true;
+        if ((0, frontmatter_1.isBlockScalarHeader)(field[2])) {
+            fields.set(field[1], '');
+            continue;
+        }
         fields.set(field[1], field[2].replace(/^(['"])(.*)\1$/, '$2').trim());
     }
     const name = fields.get('name') ?? '';
-    const description = fields.get('description') ?? '';
+    // La descripcion sale de la funcion compartida (resuelve block scalars y
+    // deshace el escape de los escalares entrecomillados) — nunca del mapa de
+    // arriba, que solo corta comillas.
+    const description = (0, frontmatter_1.readFrontmatterDescription)(match[1]);
     const instructions = match[2].trim();
     if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))
         throw new Error('invalid agent name');

package/dist/src/core/renderers/skill-source.js

@@ -10,7 +10,7 @@ exports.parseSkillSource = parseSkillSource;
 // link. Reuses discovery.ts's `matchFrontmatterBlock` (already the single
 // source of truth for locating the frontmatter block elsewhere in this
 // codebase) rather than writing a second frontmatter parser.
-const discovery_1 = require("../discovery");
+const frontmatter_1 = require("../frontmatter");
 /**
  * Parses a raw SKILL.md source into its `description` frontmatter field and
  * body content. Mirrors discovery.ts's `readArtifactDescription` for the
@@ -20,26 +20,18 @@ const discovery_1 = require("../discovery");
  * empty description or body.
  */
 function parseSkillSource(source) {
-    const frontmatter = (0, discovery_1.matchFrontmatterBlock)(source);
+    const frontmatter = (0, frontmatter_1.matchFrontmatterBlock)(source);
     if (frontmatter === null)
         throw new Error('skill source requires YAML frontmatter');
-    const line = frontmatter.split(/\r?\n/).find((l) => /^description\s*:/.test(l));
-    if (!line)
-        throw new Error('skill source requires a non-empty description');
-    let description = line.replace(/^description\s*:/, '').trim();
-    if ((description.startsWith('"') && description.endsWith('"')) ||
-        (description.startsWith("'") && description.endsWith("'"))) {
-        description = description.slice(1, -1);
-    }
-    // A YAML block scalar indicator (`>-`, `|-`, `>`, `|`, `>+`, `|+`) means the
-    // real description text lives on the FOLLOWING indented lines, not on this
-    // line at all — treating the bare indicator as the description would embed
-    // literal "|-" into every rendered skill. Mirrors discovery.ts's
-    // readArtifactDescription, which detects the same shape and treats it as
-    // absent rather than mis-parsing it.
-    const BLOCK_INDICATORS = new Set(['>-', '>', '|-', '|', '>+', '|+']);
-    if (BLOCK_INDICATORS.has(description))
-        description = '';
+    // Delega en readFrontmatterDescription (discovery.ts) — la MISMA funcion
+    // que usa el discovery del CLI, incluyendo la resolucion de block scalars
+    // (`description: >-` + lineas indentadas). Antes esta funcion tenia su
+    // propia copia de la logica, y ambas colapsaban el indicador de block
+    // scalar a '' en vez de leer el texto de las lineas siguientes: eso
+    // crasheaba `awm add <bundle> -a copilot|cursor` contra un skill real del
+    // registry baseline. Una sola implementacion = no pueden volver a
+    // divergir.
+    const description = (0, frontmatter_1.readFrontmatterDescription)(frontmatter);
     if (!description)
         throw new Error('skill source requires a non-empty description');
     const bodyMatch = source.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/);

package/dist/src/ui/text.js

@@ -30,11 +30,19 @@ function displayWidth(s) {
     }
     return w;
 }
-/** Truncate plain text to `width` cells, appending '…'. Strips ANSI — color AFTER truncating. */
+/** Truncate plain text to `width` cells, appending '…'. Strips ANSI — color AFTER truncating.
+ *
+ *  Los saltos de linea se colapsan a un espacio: esto se usa para celdas de UNA
+ *  linea (filas de `awm list`), y `displayWidth` cuenta un `\n` como ancho 1 en
+ *  vez de reconocerlo como salto — o sea que una string multilinea podia pasar
+ *  el chequeo de ancho y emitirse cruda, partiendo la fila y desalineando todo
+ *  lo que viniera despues. Antes era inalcanzable; dejo de serlo cuando el
+ *  lector de frontmatter aprendio a resolver block scalars literales (`|`), que
+ *  producen saltos de linea REALES en la descripcion. */
 function truncate(s, width) {
     if (width <= 0)
         return '';
-    const plain = stripAnsi(s);
+    const plain = stripAnsi(s).replace(/\s*\r?\n\s*/g, ' ');
     if (displayWidth(plain) <= width)
         return plain;
     if (width === 1)

package/dist/tests/core/diagnostics/context.test.js

@@ -103,6 +103,27 @@ describe('gatherContext', () => {
         // must surface as a broken/missing link — NOT a clean, skippable state.
         expect(ctx.machine.devCore.brokenLinks).toContain('development-process.toml');
     });
+    // Regression for the confirmed production bug: `awm init -a copilot` crashed
+    // 100% of the time with "machine.devCore: skill global scope is not
+    // supported by Copilot...", rolling back the whole init transaction.
+    // Copilot has no global skill directory (providers/index.ts's
+    // `skill.global === null`) — before this fix, devCorePresent was
+    // unconditionally false in that case (linked/broken forced to empty
+    // arrays), so `machine.devCore` could never be satisfied and stepDevCore
+    // (init/steps.ts) fell through to a global-scope installBundle call every
+    // single run, which throws for Copilot. Now it's reported as trivially
+    // satisfied ("N/A" == "nothing to do"), matching how `globalSkills`
+    // already treats the same null-skillsDir case.
+    it('machine: devCore is trivially satisfied (present, no broken links) for an agent with no global skill directory (copilot)', () => {
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({
+            cwd: tmpHome,
+            bundles: [bundle('dev-core', 'baseline', ['brainstorming'])],
+            agent: 'copilot',
+        });
+        expect(ctx.machine.devCore.present).toBe(true);
+        expect(ctx.machine.devCore.brokenLinks).toEqual([]);
+    });
     it('machine: ambient wanted read from ~/.awm/config.json, installed reflects links', () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'config.json'), JSON.stringify({ ambient: ['personal-notion'] }));
@@ -116,6 +137,29 @@ describe('gatherContext', () => {
         expect(ctx.machine.ambient.wanted).toEqual(['personal-notion']);
         expect(ctx.machine.ambient.installed).toEqual(['personal-notion']);
     });
+    // Regression for the SAME structural bug as the devCore fix above, just in
+    // the `ambient` computation a few lines below it: Copilot has no global
+    // skill directory (skill.global === null), so before this fix `installed`
+    // was forced to `[]` unconditionally regardless of `wanted`. That made
+    // `stepAmbient` (init/steps.ts) treat every entry in a machine-level
+    // `~/.awm/config.json`'s `ambient` array as permanently missing and call
+    // installBundle at GLOBAL scope for Copilot — which throws with the exact
+    // same "skill global scope is not supported by Copilot" error the devCore
+    // bug had, and rolls back the whole init transaction. Now `installed`
+    // mirrors `wanted` when skillsDir is null (N/A treated as satisfied,
+    // nothing to install), matching devCore's treatment above.
+    it('machine: ambient is trivially satisfied (installed mirrors wanted) for an agent with no global skill directory (copilot)', () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'config.json'), JSON.stringify({ ambient: ['personal-notion'] }));
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const bundles = [
+            bundle('dev-core', 'baseline', ['brainstorming']),
+            bundle('personal-notion', 'ambient', ['notion-skill']),
+        ];
+        const ctx = gatherContext({ cwd: tmpHome, bundles, agent: 'copilot' });
+        expect(ctx.machine.ambient.wanted).toEqual(['personal-notion']);
+        expect(ctx.machine.ambient.installed).toEqual(['personal-notion']);
+    });
     it('machine: contextInjection empty when opencode config is absent', () => {
         const { gatherContext } = require('../../../src/core/diagnostics/context');
         const ctx = gatherContext({ cwd: tmpHome, bundles: [] });