agentic-workflow-manager 3.13.6 → 4.0.0

package/dist/scripts/support-matrix.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOC_PATH = exports.END_MARKER = exports.BEGIN_MARKER = void 0;
+exports.homeRelative = homeRelative;
+exports.renderProviderTables = renderProviderTables;
+exports.spliceGenerated = spliceGenerated;
+// Generador de la matriz de soporte que vive en `docs/support-matrix.md`.
+//
+// Existe porque la tabla escrita a mano ya mintio: decia que Antigravity instalaba en
+// `~/.agents/skills` y `.agents/skills` cuando el codigo dice `~/.gemini/antigravity/skills`
+// y `.agent/skills` (singular), y omitia que es el unico provider con `global_workflows`.
+// Una tabla de soporte que no coincide con el codigo es peor que no tenerla: se cita en
+// una presentacion, se planifica encima, y nadie la vuelve a chequear.
+//
+// El bloque generado esta delimitado por marcadores en el .md, y
+// `tests/structural/support-matrix-is-current.test.ts` regenera y compara — asi que un
+// cambio en `providers/index.ts` que no se refleje en el doc pone la CI en rojo. La
+// verificabilidad no depende de que alguien se acuerde.
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../src/providers");
+const paths_1 = require("../src/core/paths");
+exports.BEGIN_MARKER = '<!-- BEGIN GENERATED: provider-capabilities -->';
+exports.END_MARKER = '<!-- END GENERATED: provider-capabilities -->';
+/** Cualquier separador → `/`. Las rutas que produce `providers()` traen el separador
+ *  nativo, y el `home` puede traer otro (en win32, un `HOME` de entorno con `/` frente a
+ *  un `path.join` que devuelve `\`). Normalizar los dos lados ANTES de compararlos es lo
+ *  unico que hace la comparacion valida. */
+const toPosix = (p) => p.split(path_1.default.sep).join('/').split('\\').join('/');
+/** Rutas absolutas → `~/…`, con separadores POSIX, para que la tabla sea la misma en
+ *  cualquier maquina y en cualquier sistema operativo que la regenere.
+ *
+ *  La version anterior comparaba con `startsWith` ANTES de normalizar, asi que en Windows
+ *  —donde `path.join` devuelve `\` y el home podia venir con `/`— el prefijo no
+ *  coincidia nunca, no abreviaba nada, y la tabla regenerada ahi no era la misma que la
+ *  comiteada. Es decir: el documento prometia ser independiente de la maquina y no lo era.
+ *  Lo encontro la CI de Windows, no el desarrollo en Linux. */
+function homeRelative(p, home) {
+    const target = toPosix(p);
+    const prefix = toPosix(home);
+    return target.startsWith(prefix) ? `~${target.slice(prefix.length)}` : target;
+}
+function cell(value, absent, home) {
+    if (value === null)
+        return absent;
+    return `\`${homeRelative(value, home)}\``;
+}
+/** El tier declarado por la forma de la config — la misma derivacion que `providerTier`
+ *  en `core/diagnostics/provider-checks.ts`, no una segunda opinion. */
+function tier(c) {
+    if (c.hooks)
+        return 'hooks-native';
+    if (c.injection?.type === 'config-instructions')
+        return 'config-managed';
+    if (c.injection)
+        return 'agents-md-managed';
+    return 'context-only';
+}
+function injectionCell(c, home) {
+    const inj = c.injection;
+    if (!inj)
+        return '— (ninguna)';
+    if (inj.type === 'cc-settings-merge')
+        return 'hook `SessionStart`';
+    if (inj.type === 'config-instructions')
+        return `\`${homeRelative(inj.configPath, home)}\` → campo \`${inj.field}\``;
+    return inj.globalPath === null
+        ? `\`${inj.localFile}\` del proyecto (sin equivalente global)`
+        : `\`${inj.localFile}\` + \`${homeRelative(inj.globalPath, home)}\``;
+}
+function renderProviderTables() {
+    // `homeDir()`, la MISMA funcion de la que `providers()` deriva sus rutas. Tomarlo
+    // por parametro daba dos fuentes para el mismo dato: el generador abreviaba contra
+    // el home real y el test contra uno inventado, asi que ninguna ruta empezaba con el
+    // prefijo esperado y la tabla salia con rutas absolutas de la maquina que la corrio.
+    const home = (0, paths_1.homeDir)();
+    const p = (0, providers_1.providers)();
+    const row = (a) => p[a];
+    const lines = [];
+    lines.push('### Dónde aterriza cada artefacto');
+    lines.push('');
+    lines.push('| Agente | Tier | Skills (global) | Skills (proyecto) | Formato |');
+    lines.push('|---|---|---|---|---|');
+    for (const a of providers_1.AGENT_TARGETS) {
+        const c = row(a);
+        lines.push(`| \`${a}\` | ${tier(c)} | ${cell(c.skill.global, '**no soportado**', home)} | \`${c.skill.local}\` | \`${c.skill.renderer}\` |`);
+    }
+    lines.push('');
+    lines.push('### Perfiles de agente, workflows, hooks y contexto');
+    lines.push('');
+    lines.push('| Agente | Perfiles de agente | Workflows | Hooks | Entrega de contexto | Versión mínima |');
+    lines.push('|---|---|---|---|---|---|');
+    for (const a of providers_1.AGENT_TARGETS) {
+        const c = row(a);
+        const agentCell = c.agent === null
+            ? '— (no aplica)'
+            : `${cell(c.agent.global, '**no soportado**', home)} · \`${c.agent.renderer}\``;
+        const wfCell = c.workflow === null
+            ? '— (no aplica)'
+            : cell(c.workflow.global, '**no soportado**', home);
+        lines.push(`| \`${a}\` | ${agentCell} | ${wfCell} | ${c.hooks ? `\`${c.hooks.type}\`` : '— (no tiene)'} ` +
+            `| ${injectionCell(c, home)} | ${c.minimumVersion ?? '— (sin gate)'} |`);
+    }
+    lines.push('');
+    lines.push('> Generado desde `cli/src/providers/index.ts`. **No editar a mano** — `npm run docs:matrix` lo regenera y');
+    lines.push('> `tests/structural/support-matrix-is-current.test.ts` falla si el documento y el código se separan.');
+    return lines.join('\n');
+}
+/** Reemplaza el bloque entre marcadores. Falla ruidosamente si faltan: un doc sin
+ *  marcadores no se "arregla" agregando la tabla al final, se arregla avisando.
+ *
+ *  Respeta el fin de linea del documento que recibe. Emitia LF siempre, asi que en un
+ *  checkout de Windows —donde git entrega el .md con CRLF por defecto— regenerar producia
+ *  un archivo de finales mezclados, y la comparacion del test fallaba por bytes que no
+ *  tienen nada que ver con el contenido de la tabla. */
+function spliceGenerated(markdown, generated) {
+    const begin = markdown.indexOf(exports.BEGIN_MARKER);
+    const end = markdown.indexOf(exports.END_MARKER);
+    if (begin === -1 || end === -1 || end < begin) {
+        throw new Error(`support-matrix.md no tiene los marcadores ${exports.BEGIN_MARKER} / ${exports.END_MARKER}`);
+    }
+    const eol = markdown.includes('\r\n') ? '\r\n' : '\n';
+    const block = generated.split('\n').join(eol);
+    return markdown.slice(0, begin + exports.BEGIN_MARKER.length)
+        + eol + eol + block + eol + eol
+        + markdown.slice(end);
+}
+exports.DOC_PATH = path_1.default.join(__dirname, '..', '..', 'docs', 'support-matrix.md');
+/* istanbul ignore next — entrypoint de CLI, ejercitado por el test via las funciones puras */
+if (require.main === module) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const fs = require('fs');
+    const current = fs.readFileSync(exports.DOC_PATH, 'utf-8');
+    fs.writeFileSync(exports.DOC_PATH, spliceGenerated(current, renderProviderTables()), 'utf-8');
+    process.stdout.write(`support-matrix.md regenerado desde providers/index.ts\n`);
+}

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

@@ -17,6 +17,7 @@ exports.planInitMutationTargets = planInitMutationTargets;
 // entry when nothing exists there yet). The one failure mode that matters is
 // under-enumeration: a real write to a path NOT in this list would land
 // outside the backup session and survive a rollback.
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../providers");
 const bundles_1 = require("../bundles");
@@ -40,6 +41,17 @@ function physicalTarget(type, agent, scope, installName, projectRoot) {
         return null;
     }
 }
+/** La forma canonica de un directorio: resuelve symlinks si existe, y si no existe
+ *  todavia devuelve la entrada tal cual — enumerar un destino aun inexistente es
+ *  deliberado en este modulo (un backup vacio no es un problema; no enumerarlo si). */
+function canonicalDir(dir) {
+    try {
+        return fs_1.default.realpathSync(dir);
+    }
+    catch {
+        return dir;
+    }
+}
 function addBundleTargets(targets, bundleName, bundles, agent, scope, projectRoot, contentDir) {
     let intents;
     try {
@@ -72,7 +84,17 @@ function addBundleTargets(targets, bundleName, bundles, agent, scope, projectRoo
  * read the project profile, but never writes).
  */
 function planInitMutationTargets(params) {
-    const { cwd, agent, bundles } = params;
+    const { agent, bundles } = params;
+    // `cwd` canonico ANTES de derivar nada de el. Algunos destinos salen de `cwd` tal
+    // cual y otros de `findProjectRoot(cwd)`, que hace `realpathSync`: mientras las dos
+    // formas coincidan el `Set` deduplica y no se nota, pero en macOS `/var/folders/…`
+    // es un symlink a `/private/var/folders/…` y entonces NO coinciden — la CI de macOS
+    // mostro `AGENTS.md` y `.awm/context/awm-context.md` dos veces, una por forma.
+    //
+    // Esta lista es la que `beginBackupSession` respalda y la que el rollback restaura.
+    // Un archivo con dos entradas es un archivo respaldado dos veces y restaurado dos
+    // veces, en el mecanismo cuyo unico trabajo es dejar el disco como estaba.
+    const cwd = canonicalDir(params.cwd);
     const targets = new Set();
     // preferences.json + the artifact ownership ledger (state/artifacts.json)
     targets.add(path_1.default.join((0, paths_1.awmHome)(), 'preferences.json'));

package/dist/src/index.js

@@ -88,9 +88,19 @@ function resolveSelectedArtifacts(selections) {
     }
     return Array.from(result.values());
 }
+// AWM instala BUNDLES, no artefactos sueltos. Es una decision de producto, no una
+// limitacion pendiente: las skills de AWM se apoyan unas en otras (el spine de
+// development-process invoca brainstorming, writing-plans, los gates de QA...), asi que
+// una skill instalada sola casi nunca hace lo que el usuario espera. Ver
+// docs/decisions.md, D-001.
+//
+// El flag `-t, --type` existia y `add.ts` NUNCA lo leia: se aceptaba y se descartaba en
+// silencio. Peor, la doc y los playbooks de aceptacion documentaban `awm add <skill>
+// --type skill` como el camino scripteado — una invocacion que siempre fallo con
+// «Bundle "<skill>" not found». Los playbooks se escribieron contra la documentacion, no
+// contra el comportamiento. Un flag que no se lee es peor que uno ausente: promete.
 program.command('add [name]')
-    .description('Add a skill, workflow, or process interactively (or non-interactively with flags)')
-    .option('-t, --type <type>', 'Artifact type: skill, workflow, or process')
+    .description('Add a bundle (package of skills) interactively, or non-interactively with flags')
     .option('-a, --agent <agent>', `Target agent: ${providers_1.AGENT_TARGETS.join(', ')}`)
     .option('-s, --scope <scope>', 'Scope: local or global')
     .option('-m, --method <method>', 'Install method: symlink or copy')

package/dist/tests/commands/watch/runner.test.js

@@ -11,6 +11,17 @@ const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
 const store_1 = require("../../../src/core/journal/store");
 const paths_1 = require("../../../src/core/journal/paths");
 const process_1 = require("../../../src/core/journal/process");
+// Presupuesto explicito POR ENCIMA del global (30s en jest.config.js), como sus tres
+// hermanos de `tests/commands/watch/`
+// (integration 30s, supervisor-loop 60s, e2e-crash 180s). Este archivo era el unico de
+// la familia sin uno, y hace el mismo trabajo que ellos: cada `collectAndReconcile`
+// consulta si el proceso sigue vivo, y en Windows eso spawnea `tasklist` — cientos de ms
+// por llamada bajo carga. El test de stall hace 3 iteraciones sobre dos refs (proceso +
+// wrapper), o sea 6 consultas, y el default de 5s de jest quedaba justo en el borde:
+// verde en dos corridas de Windows y timeout en la tercera, sin que cambiara el codigo.
+// El sujeto del test es la semantica de deteccion de stall, no cuanto tarda; el reloj
+// generoso no afloja ninguna asercion.
+jest.setTimeout(60000);
 const fakeSpawner = (job, nonce, logsRoot, repoRoot) => {
     // Mismo contrato que el spawner real: dispara el wrapper y NO espera.
     void (0, exec_wrapper_1.runExecWrapper)({ logsRoot, jobId: job.id, nonce, argv: job.argv, cwd: job.cwd, repoRoot }).catch(() => { });

package/dist/tests/core/init/context-injection-no-project.test.js

@@ -31,11 +31,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // purpose, and this step read that as "no project found" and wrote into cwd anyway —
 // under the one flag whose entire promise is that it won't touch the project.
 const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const steps_1 = require("../../../src/core/init/steps");
 const mutation_targets_1 = require("../../../src/core/init/mutation-targets");
 const materializer_1 = require("../../../src/core/context/materializer");
+const tmp_1 = require("../../support/tmp");
 function deps(agent, cwd, projectRoot, machineOnly = false) {
     const installed = [];
     const d = {
@@ -61,7 +61,7 @@ function deps(agent, cwd, projectRoot, machineOnly = false) {
 }
 describe('project-scope context injection without a project', () => {
     let cwd;
-    beforeEach(() => { cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-noproj-')); });
+    beforeEach(() => { cwd = (0, tmp_1.mkCanonicalTmpDir)('awm-noproj-'); });
     afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
     it.each(['copilot', 'cursor'])('%s: writes nothing at all under --machine-only', (agent) => {
         const { d, installed } = deps(agent, cwd, null, true);
@@ -103,7 +103,7 @@ describe('project-scope context injection without a project', () => {
 });
 describe('mutation-targets covers the local-scope context paths independently', () => {
     let cwd;
-    beforeEach(() => { cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-noproj-mt-')); });
+    beforeEach(() => { cwd = (0, tmp_1.mkCanonicalTmpDir)('awm-noproj-mt-'); });
     afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
     it.each(['copilot', 'cursor'])('%s: enumerates AGENTS.md and .awm/context even with no project root', (agent) => {
         const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd, agent, bundles: [] });

package/dist/tests/core/init/mutation-targets-canonical.test.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `planInitMutationTargets` mezclaba dos formas de la misma ruta.
+//
+// Deriva algunos destinos de `cwd` tal como lo recibe, y otros de
+// `findProjectRoot(cwd)` — que hace `realpathSync`. Mientras las dos coincidan, el `Set`
+// deduplica y nadie lo nota. En macOS NO coinciden: `/var/folders/…` es un symlink a
+// `/private/var/folders/…`, asi que la CI de macOS mostro `AGENTS.md` y
+// `.awm/context/awm-context.md` DOS VECES en la lista de destinos, una por cada forma:
+//
+//     /var/folders/…/AGENTS.md              ← derivado de cwd
+//     /private/var/folders/…/AGENTS.md      ← derivado de findProjectRoot(cwd)
+//
+// Esa lista es lo que `beginBackupSession` respalda y lo que el rollback restaura. Un
+// mismo archivo entrando dos veces significa dos entradas de backup para un solo
+// archivo, y un rollback que lo restaura dos veces — sobre un mecanismo cuyo unico
+// trabajo es dejar el disco exactamente como estaba.
+//
+// El bug no necesita macOS: cualquier `cwd` que pase por un symlink lo reproduce. Este
+// test arma esa situacion a mano, asi que corre igual en los tres sistemas.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const mutation_targets_1 = require("../../../src/core/init/mutation-targets");
+describe('los destinos de mutacion son canonicos: un archivo, una entrada', () => {
+    let real;
+    let linkDir;
+    beforeEach(() => {
+        // `real` es el directorio de verdad; `linkDir` es un symlink que apunta ahi.
+        // Pasar `linkDir` como cwd es exactamente lo que hace macOS con /var → /private/var.
+        const base = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-canon-')));
+        real = path_1.default.join(base, 'real');
+        linkDir = path_1.default.join(base, 'link');
+        fs_1.default.mkdirSync(path_1.default.join(real, '.git'), { recursive: true }); // marcador de proyecto
+        fs_1.default.symlinkSync(real, linkDir, 'dir');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(path_1.default.dirname(real), { recursive: true, force: true });
+    });
+    /** Todo destino resuelto a su forma canonica: dos entradas que resuelven al mismo
+     *  archivo son la misma entrada, sin importar como se escribieron. */
+    const canonical = (p) => {
+        try {
+            return fs_1.default.realpathSync(p);
+        }
+        catch { /* aun no existe */ }
+        const parent = path_1.default.dirname(p);
+        try {
+            return path_1.default.join(fs_1.default.realpathSync(parent), path_1.default.basename(p));
+        }
+        catch {
+            return p;
+        }
+    };
+    it.each(['copilot', 'cursor'])('%s: no enumera el mismo archivo dos veces cuando cwd pasa por un symlink', (agent) => {
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd: linkDir, agent, bundles: [] });
+        const seen = new Map();
+        for (const t of targets) {
+            const key = canonical(t);
+            seen.set(key, [...(seen.get(key) ?? []), t]);
+        }
+        const duplicados = [...seen.entries()].filter(([, forms]) => forms.length > 1);
+        expect(duplicados).toEqual([]);
+    });
+    it('sigue enumerando AGENTS.md y el contexto materializado — deduplicar no es perder', () => {
+        // La correccion es colapsar formas equivalentes, NO dejar de cubrir el archivo:
+        // sub-enumerar es el unico modo de falla que derrota el rollback en silencio.
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd: linkDir, agent: 'copilot', bundles: [] })
+            .map(canonical);
+        expect(targets).toContain(path_1.default.join(real, 'AGENTS.md'));
+        expect(targets).toContain(path_1.default.join(real, '.awm', 'context', 'awm-context.md'));
+    });
+    it('no depende del symlink: con un cwd ya canonico da el mismo resultado', () => {
+        const viaLink = (0, mutation_targets_1.planInitMutationTargets)({ cwd: linkDir, agent: 'copilot', bundles: [] }).map(canonical).sort();
+        const viaReal = (0, mutation_targets_1.planInitMutationTargets)({ cwd: real, agent: 'copilot', bundles: [] }).map(canonical).sort();
+        expect(viaLink).toEqual(viaReal);
+    });
+});

package/dist/tests/core/init/mutation-targets.test.js

@@ -17,9 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // tests/core/skill-integrity.test.ts. Per CLAUDE.md, no test may touch the
 // real ~/.awm.
 const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const materializer_1 = require("../../../src/core/context/materializer");
+const tmp_1 = require("../../support/tmp");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
@@ -32,7 +32,7 @@ let originalHome;
 let originalAwmHome;
 let extraDirs;
 beforeEach(() => {
-    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-'));
+    tmpHome = (0, tmp_1.mkCanonicalTmpDir)('awm-mutation-targets-');
     originalHome = process.env.HOME;
     originalAwmHome = process.env.AWM_HOME;
     process.env.HOME = tmpHome;
@@ -67,7 +67,7 @@ function load() {
 }
 /** A cwd guaranteed to have no project-root marker (.git/package.json/.awm) in its ancestry. */
 function bareCwd() {
-    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-cwd-'));
+    const dir = (0, tmp_1.mkCanonicalTmpDir)('awm-mutation-targets-cwd-');
     extraDirs.push(dir);
     return dir;
 }
@@ -158,7 +158,7 @@ describe('planInitMutationTargets', () => {
     });
     describe('project-level targets', () => {
         function makeProjectRoot() {
-            const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-project-'));
+            const root = (0, tmp_1.mkCanonicalTmpDir)('awm-mutation-targets-project-');
             fs_1.default.mkdirSync(path_1.default.join(root, '.git')); // project-root marker for findProjectRoot
             extraDirs.push(root);
             return root;

package/dist/tests/core/project-skill-links.test.js

@@ -22,17 +22,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // For Copilot the gap is total, not partial: `skill.global` is null, so *every* skill
 // it has is project-scope, and none of them had any integrity path whatsoever.
 const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const skill_integrity_1 = require("../../src/core/skill-integrity");
 const providers_1 = require("../../src/providers");
+const tmp_1 = require("../support/tmp");
 describe('project-scope skill links get the same integrity path as global ones', () => {
     let registry;
     let projectRoot;
     const made = [];
     beforeEach(() => {
-        registry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-projlink-reg-'));
-        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-projlink-proj-'));
+        registry = (0, tmp_1.mkCanonicalTmpDir)('awm-projlink-reg-');
+        projectRoot = (0, tmp_1.mkCanonicalTmpDir)('awm-projlink-proj-');
         made.push(registry, projectRoot);
         fs_1.default.mkdirSync(path_1.default.join(registry, 'skills', 'alive'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(registry, 'skills', 'alive', 'SKILL.md'), '# alive\n');
@@ -104,7 +104,7 @@ describe('awm sync reaches the project-scope reconciliation', () => {
     let saved;
     beforeEach(() => {
         jest.resetModules();
-        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-syncwire-home-'));
+        home = (0, tmp_1.mkCanonicalTmpDir)('awm-syncwire-home-');
         saved = { HOME: process.env.HOME, AWM_HOME: process.env.AWM_HOME };
         process.env.HOME = home;
         process.env.AWM_HOME = path_1.default.join(home, '.awm');
@@ -113,7 +113,7 @@ describe('awm sync reaches the project-scope reconciliation', () => {
             enabledAgents: ['claude-code'], defaultAgent: 'claude-code',
             installMethod: 'symlink', defaultScope: 'global',
         }));
-        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-syncwire-proj-'));
+        projectRoot = (0, tmp_1.mkCanonicalTmpDir)('awm-syncwire-proj-');
         fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
     });
     afterEach(() => {

package/dist/tests/structural/support-matrix-is-current.test.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Guarda estructural: `docs/support-matrix.md` no puede desalinearse de
+// `src/providers/index.ts`.
+//
+// La tabla escrita a mano ya mintio. Decia que Antigravity instalaba en
+// `~/.agents/skills` y `.agents/skills`; el codigo dice `~/.gemini/antigravity/skills` y
+// `.agent/skills` — singular — y ademas es el unico provider con `global_workflows`, cosa
+// que la tabla ni mencionaba. Nadie lo noto porque nada obligaba a mirarlo: la tabla se
+// escribio una vez, el codigo siguio cambiando, y el documento se cita en presentaciones y
+// se planifica encima.
+//
+// Este test hace que ese desvio sea imposible de mergear. No verifica que la tabla sea
+// "linda": verifica que sea LA MISMA que produce el codigo hoy.
+const fs_1 = __importDefault(require("fs"));
+const support_matrix_1 = require("../../scripts/support-matrix");
+describe('docs/support-matrix.md refleja el codigo', () => {
+    it('el bloque generado esta al dia', () => {
+        const doc = fs_1.default.readFileSync(support_matrix_1.DOC_PATH, 'utf-8');
+        const expected = (0, support_matrix_1.spliceGenerated)(doc, (0, support_matrix_1.renderProviderTables)());
+        // Mensaje accionable: el que rompe esto casi siempre acaba de tocar
+        // providers/index.ts y no sabe que este documento existe.
+        expect(doc).toBe(expected);
+    });
+    it('el documento conserva sus marcadores', () => {
+        const doc = fs_1.default.readFileSync(support_matrix_1.DOC_PATH, 'utf-8');
+        expect(doc).toContain(support_matrix_1.BEGIN_MARKER);
+        expect(doc).toContain(support_matrix_1.END_MARKER);
+    });
+    it('la tabla nombra a los seis providers declarados', () => {
+        // Que el bloque este "al dia" no sirve si el generador se olvidara de un provider:
+        // doc y generador coincidirian, los dos incompletos.
+        const { AGENT_TARGETS } = require('../../src/providers');
+        const generated = (0, support_matrix_1.renderProviderTables)();
+        for (const agent of AGENT_TARGETS) {
+            expect(generated).toContain(`\`${agent}\``);
+        }
+    });
+    it('abrevia el home y usa separadores POSIX, para no depender de la maquina', () => {
+        // Con un HOME inventado: si la tabla dependiera de la maquina que la genera, este
+        // home apareceria literal en la salida y el doc comiteado cambiaria segun quien
+        // corriera el generador — el test de arriba se volveria ruido permanente.
+        const saved = process.env.HOME;
+        process.env.HOME = '/home/inventado';
+        try {
+            jest.resetModules();
+            const { renderProviderTables: fresh } = require('../../scripts/support-matrix');
+            const generated = fresh();
+            expect(generated).toContain('`~/.claude/skills`');
+            expect(generated).not.toContain('/home/inventado');
+            expect(generated).not.toContain('\\');
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = saved;
+            jest.resetModules();
+        }
+    });
+    // La abreviacion a `~` se probaba solo end-to-end, y en Linux eso no distingue entre
+    // "normaliza bien" y "los separadores ya coincidian". La CI de Windows encontro que no
+    // normalizaba: comparaba el prefijo ANTES de convertir separadores, asi que alla no
+    // abreviaba nada y la tabla regenerada no era la comiteada. Probar la unidad con las
+    // dos formas de ruta lo detecta en cualquier sistema, sin fingir la plataforma.
+    describe('homeRelative normaliza antes de comparar', () => {
+        it.each([
+            ['posix', '/home/x', '/home/x/.claude/skills', '~/.claude/skills'],
+            ['win32', 'C:\\Users\\x', 'C:\\Users\\x\\.claude\\skills', '~/.claude/skills'],
+            ['mixto', '/home/x', '\\home\\x\\.claude\\skills', '~/.claude/skills'],
+            ['sin prefijo', '/home/x', '/opt/otro/skills', '/opt/otro/skills'],
+        ])('%s', (_n, home, input, expected) => {
+            expect((0, support_matrix_1.homeRelative)(input, home)).toBe(expected);
+        });
+        it('nunca deja un separador de Windows en la salida', () => {
+            expect((0, support_matrix_1.homeRelative)('C:\\Users\\x\\.codex\\agents', 'C:\\Users\\x')).not.toContain('\\');
+        });
+    });
+    it('respeta el fin de linea del documento (un checkout de Windows entrega CRLF)', () => {
+        // Sin esto, regenerar en Windows dejaba el archivo con finales mezclados y el test
+        // de arriba fallaba por bytes ajenos al contenido. Es el mismo error de fondo que
+        // el de los separadores: asumir la forma de POSIX para un dato que la plataforma
+        // decide.
+        const crlfDoc = `intro\r\n${support_matrix_1.BEGIN_MARKER}\r\nviejo\r\n${support_matrix_1.END_MARKER}\r\nfin\r\n`;
+        const out = (0, support_matrix_1.spliceGenerated)(crlfDoc, 'linea uno\nlinea dos');
+        expect(out).toContain('linea uno\r\nlinea dos');
+        expect(out.split('\r\n').length - 1).toBe(out.split('\n').length - 1); // ni un LF suelto
+    });
+    it('marca como no soportado, no como ausente, el scope que un provider no tiene', () => {
+        // La diferencia entre "no soportado" y una celda vacia es exactamente lo que el
+        // documento existe para no dejar ambiguo: Copilot no tiene scope global por
+        // decision del producto que integramos, no porque falte implementarlo.
+        const generated = (0, support_matrix_1.renderProviderTables)();
+        const copilotRow = generated.split('\n').find((l) => l.startsWith('| `copilot` |'));
+        expect(copilotRow).toContain('**no soportado**');
+    });
+});

package/dist/tests/support/tmp.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mkCanonicalTmpDir = mkCanonicalTmpDir;
+// Directorios temporales en forma canonica, para tests que comparan rutas.
+//
+// En macOS `os.tmpdir()` devuelve `/var/folders/…`, que es un SYMLINK a
+// `/private/var/folders/…`. El producto resuelve el root del proyecto con `realpathSync`
+// (`findProjectRoot`, `core/profile.ts`), asi que devuelve la forma canonica. Un test que
+// arma su expectativa con el `mkdtemp` crudo compara `/var/…` contra `/private/var/…` y
+// falla sobre un producto que se comporta bien. En Linux y Windows las dos formas
+// coinciden, asi que el problema es invisible hasta que corre en macOS — paso tres veces
+// en la primera corrida de macOS en CI.
+//
+// Usar esto en cualquier test que:
+//   - compare una ruta contra la que devuelve el producto, o
+//   - le pase el tmpdir al producto y despues afirme sobre lo que salio.
+//
+// Un test que solo escribe y lee archivos bajo su tmpdir no lo necesita: las dos formas
+// llegan al mismo inodo. Por eso esto es un helper y no una migracion masiva — envolver
+// los 113 archivos que crean tmpdirs seria ruido, no rigor.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/** `fs.mkdtempSync` + `realpathSync`: el mismo directorio, en la forma que el producto
+ *  va a usar. El `realpathSync` no puede fallar — el directorio acaba de crearse. */
+function mkCanonicalTmpDir(prefix) {
+    return fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), prefix)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "3.13.6",
+  "version": "4.0.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"
@@ -23,7 +23,8 @@
     "prerelease": "npm run build",
     "release": "node dist/src/release/index.js",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "docs:matrix": "ts-node scripts/support-matrix.ts"
   },
   "keywords": [
     "agentic",