agentic-workflow-manager 6.1.2 → 6.2.1

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

@@ -67,7 +67,7 @@ function binaryVersionCheck(agent) {
  *  verificacion que no ocurria. Ahora tambien comprueba contenido, con el marcador que
  *  declara el renderer (`rendererIntegrityMarker`): un archivo con la extension correcta
  *  y el cuerpo vacio o truncado ya no pasa como sano. */
-function skillsGlobalCheck(dir, owners, integrity, renderer) {
+function skillsGlobalCheck(dir, owners, integrity, renderer, artifacts) {
     if (dir === null)
         return null;
     if (renderer !== 'link') {
@@ -107,18 +107,41 @@ function skillsGlobalCheck(dir, owners, integrity, renderer) {
         // Comprobar presencia y extension dejaba pasar un archivo correcto por fuera y
         // vacio o truncado por dentro — el agente cargaba nada y doctor decia que si.
         const corrupt = corruptRendered(dir, rendered, renderer);
+        if (corrupt.length > 0) {
+            return {
+                id: 'skills.global', state: 'broken', target: dir,
+                owners: owners.length > 1 ? owners : undefined,
+                detail: `${corrupt.length} rendered file(s) missing their expected content (${corrupt.slice(0, 3).join(', ')})`,
+                // Codigo propio: no es una usurpacion (nadie lo reemplazo por otra cosa) ni
+                // un symlink colgante. Es nuestro archivo, con el contenido incompleto — lo
+                // arregla re-instalar el bundle, que lo reescribe.
+                remediationCode: 'reinstall-rendered-artifacts',
+            };
+        }
+        // Frescura, DESPUES de integridad: un archivo truncado tambien difiere de su
+        // fuente, y "incompleto" es mas util que "viejo". Solo aplica a renderizados — un
+        // symlink apunta al registry, asi que `awm update` lo actualiza solo. Los
+        // generados NO: quedan con el contenido de la version anterior hasta que alguien
+        // corra `awm sync`, y hasta ahora nada lo decia.
+        const stale = staleRendered(dir, artifacts);
+        const names = stale.map((r) => path_1.default.basename(r.targetPath));
         return {
             id: 'skills.global',
-            state: corrupt.length > 0 ? 'broken' : 'supported',
+            state: stale.length > 0 ? 'stale' : 'supported',
             target: dir,
             owners: owners.length > 1 ? owners : undefined,
-            detail: corrupt.length > 0
-                ? `${corrupt.length} rendered file(s) missing their expected content (${corrupt.slice(0, 3).join(', ')})`
+            detail: stale.length > 0
+                ? `${stale.length} rendered file(s) no longer match the installed registry (${names.slice(0, 3).join(', ')})`
+                : undefined,
+            // El remedio depende del ALCANCE, y se midio cual funciona en cada uno:
+            // `awm update` reconcilia los artefactos de maquina, `awm sync` los que el
+            // profile del proyecto declara. Ofrecer el equivocado seria mandar al usuario
+            // a un comando que corre limpio sin cambiar nada — el defecto que ya tuvo
+            // `open-hooks-trust` (D-010), y que la primera version de ESTE chequeo
+            // repitio: ofrecia `reinstall-bundle` porque dos mediciones mias estaban mal.
+            remediationCode: stale.length > 0
+                ? (stale.some((r) => r.scope === 'local') ? 'awm-sync' : 'awm-update')
                 : undefined,
-            // Codigo propio: no es una usurpacion (nadie lo reemplazo por otra cosa) ni un
-            // symlink colgante. Es nuestro archivo, con el contenido incompleto — lo
-            // arregla re-instalar el bundle, que lo reescribe.
-            remediationCode: corrupt.length > 0 ? 'reinstall-rendered-artifacts' : undefined,
         };
     }
     const shared = owners.length > 1;
@@ -178,6 +201,24 @@ function skillsGlobalCheck(dir, owners, integrity, renderer) {
  * Un archivo ilegible cuenta como corrupto: no poder leerlo no es evidencia de que este
  * bien. Es la misma disciplina que el resto de los checks — nunca verde por no mirar.
  */
+function staleRendered(dir, records) {
+    return records
+        .filter((r) => r.renderer !== 'link' && path_1.default.dirname(r.targetPath) === dir)
+        .filter((r) => {
+        try {
+            const expected = (0, registry_1.renderArtifact)(r.renderer, r.sourcePath);
+            if (expected === null)
+                return false;
+            return fs_1.default.readFileSync(r.targetPath, 'utf8') !== expected;
+        }
+        catch {
+            // Fuente ausente (el registry ya no la trae) o target ilegible: no es
+            // desactualizacion, es otra cosa, y la reportan los checks que
+            // corresponden. Aca "no puedo comparar" no se convierte en "esta viejo".
+            return false;
+        }
+    });
+}
 function corruptRendered(dir, files, renderer) {
     const marker = (0, registry_1.rendererIntegrityMarker)(renderer);
     if (marker === null)
@@ -411,6 +452,10 @@ function gatherProviderChecks(agents, scanSkills, projectRoot) {
     for (const dir of ownersByDir.keys()) {
         scansByDir.set(dir, scanSkills(dir));
     }
+    // El ledger se lee UNA vez por corrida y se comparte: es la unica forma de saber
+    // que fuente produjo cada artefacto renderizado, y por lo tanto de preguntar si
+    // sigue coincidiendo con ella.
+    const artifacts = safeArtifactState();
     return agents.map((agent) => {
         const provider = (0, providers_1.providerFor)(agent);
         const dir = provider.skill.global;
@@ -419,7 +464,7 @@ function gatherProviderChecks(agents, scanSkills, projectRoot) {
             ?? { valid: [], repairable: [], dead: [], usurped: [] };
         const checks = [
             binaryVersionCheck(agent),
-            skillsGlobalCheck(dir, owners, integrity, provider.skill.renderer),
+            skillsGlobalCheck(dir, owners, integrity, provider.skill.renderer, artifacts),
             agentsNativeCheck(agent),
             workflowsGlobalCheck(agent),
             hookTrustCheck(agent),

package/dist/src/core/install-transaction.js

@@ -30,9 +30,7 @@ const crypto_1 = __importDefault(require("crypto"));
 const artifact_state_1 = require("./artifact-state");
 const paths_1 = require("./paths");
 const atomic_file_1 = require("./atomic-file");
-const codex_agent_1 = require("./renderers/codex-agent");
-const cursor_mdc_1 = require("./renderers/cursor-mdc");
-const copilot_instructions_1 = require("./renderers/copilot-instructions");
+const registry_1 = require("./renderers/registry");
 const executor_1 = require("./executor");
 /**
  * The single timestamp-sanitization rule for transaction IDs, shared by
@@ -249,9 +247,6 @@ function stageRenderedFile(content, targetPath) {
  * are sourced from that directory's SKILL.md, so every call site needs this
  * same one-line join instead of reading `op.sourcePath` directly.
  */
-function readSkillMdSource(op) {
-    return fs_1.default.readFileSync(path_1.default.join(op.sourcePath, 'SKILL.md'), 'utf8');
-}
 /**
  * The real, filesystem-touching TransactionDeps used by applyInstallPlan by
  * default. Renders `codex-agent-toml`/`cursor-mdc`/`copilot-instructions`
@@ -270,15 +265,10 @@ function defaultTransactionDeps() {
             }
             // Renders without writing anything, purely to surface parse errors
             // before any backup/replace happens.
-            if (op.renderer === 'codex-agent-toml') {
-                (0, codex_agent_1.renderCodexAgent)(fs_1.default.readFileSync(op.sourcePath, 'utf8'));
-            }
-            else if (op.renderer === 'cursor-mdc') {
-                (0, cursor_mdc_1.renderCursorMdc)(readSkillMdSource(op));
-            }
-            else if (op.renderer === 'copilot-instructions') {
-                (0, copilot_instructions_1.renderCopilotInstructions)(readSkillMdSource(op));
-            }
+            // Renderiza y descarta: el objetivo es que un error de parseo salte ANTES
+            // de tocar nada. El dispatch sale de la tabla (`renderArtifact`), no de una
+            // copia local — esta era una de las dos que habia en este archivo.
+            (0, registry_1.renderArtifact)(op.renderer, op.sourcePath);
         },
         backup(op, backupDir) {
             if (createdAt === null)
@@ -295,19 +285,11 @@ function defaultTransactionDeps() {
             return entry.existed ? path_1.default.join(backupDir, entry.backupRelPath) : null;
         },
         stage(op) {
-            if (op.renderer === 'codex-agent-toml') {
-                const rendered = (0, codex_agent_1.renderCodexAgent)(fs_1.default.readFileSync(op.sourcePath, 'utf8'));
-                return stageRenderedFile(rendered, op.targetPath);
-            }
-            if (op.renderer === 'cursor-mdc') {
-                const rendered = (0, cursor_mdc_1.renderCursorMdc)(readSkillMdSource(op));
-                return stageRenderedFile(rendered, op.targetPath);
-            }
-            if (op.renderer === 'copilot-instructions') {
-                const rendered = (0, copilot_instructions_1.renderCopilotInstructions)(readSkillMdSource(op));
-                return stageRenderedFile(rendered, op.targetPath);
-            }
-            return (0, executor_1.stageArtifact)(op.sourcePath, op.targetPath, op.method);
+            const rendered = (0, registry_1.renderArtifact)(op.renderer, op.sourcePath);
+            // `null` = renderer `link`: no genera contenido, se instala el artefacto tal cual.
+            return rendered === null
+                ? (0, executor_1.stageArtifact)(op.sourcePath, op.targetPath, op.method)
+                : stageRenderedFile(rendered, op.targetPath);
         },
         replace(op, staged) {
             (0, executor_1.replaceArtifact)(staged, op.targetPath);

package/dist/src/core/profile.js

@@ -154,5 +154,19 @@ function ensureSkillsGitignored(root, agents) {
  * project extensions and stay out of `.awm/profile.json`.
  */
 function shouldRecordExtension(bundleScope, effective) {
-    return bundleScope === 'project' && effective === 'local';
+    // El criterio es el ALCANCE EFECTIVO, no el del bundle.
+    //
+    // Antes exigia ademas `bundleScope === 'project'`, asi que un bundle baseline
+    // instalado explicitamente con `--scope local` no quedaba registrado en ningun lado:
+    // `awm sync` reconcilia lo que declara el profile, y esos artefactos no estaban ahi.
+    // Resultado: nadie los refrescaba nunca. `update` cubre lo global y `sync` lo del
+    // profile; eso caia en el medio.
+    //
+    // Y no es un caso raro: `awm add dev --scope local` es exactamente lo que el playbook
+    // de aceptacion (AG-03) le pide correr a cualquiera que verifique un proveedor.
+    //
+    // Si alguien pidio artefactos de proyecto, el profile lo dice — que es lo que hace
+    // que un companero que clona el repo y corre `awm sync` obtenga lo mismo.
+    void bundleScope;
+    return effective === 'local';
 }

package/dist/src/core/renderers/registry.js

@@ -1,8 +1,40 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderedFilename = renderedFilename;
 exports.rendererExtension = rendererExtension;
 exports.rendererIntegrityMarker = rendererIntegrityMarker;
+exports.renderArtifact = renderArtifact;
+// src/core/renderers/registry.ts
+//
+// Modulo HOJA: la UNICA fuente de verdad sobre "que archivo produce cada
+// renderer en disco".
+//
+// Por que existe. Ese hecho estaba escrito a mano en TRES lugares divergentes
+// — `physicalTarget` (install-planner.ts, el escritor), `RENDERED_SKILL_EXTENSIONS`
+// (diagnostics/provider-checks.ts, que ademas omitia `codex-agent-toml`), y un
+// ternario suelto para agentes en diagnostics/context.ts — y estaba AUSENTE en
+// el cuarto, `classifyLinks`, que es justamente el que decide si un artefacto
+// "esta instalado".
+//
+// La consecuencia no fue teorica: el escritor dejaba `using-awm.mdc` en disco y
+// el lector buscaba `using-awm`, asi que para Cursor y Copilot
+//   - `awm init` NUNCA era idempotente (reinstalaba el baseline entero en cada
+//     corrida, dejando 2 directorios de backup sin podar por corrida), y
+//   - `awm doctor` mostraba un rojo permanente cuyo remedio no podia satisfacerlo.
+// Lo mismo para los artefactos `agent` de claude-code, el provider por defecto.
+//
+// Regla: NINGUN modulo vuelve a derivar una extension a mano. Si aparece un
+// renderer nuevo, se agrega aca y todos los consumidores quedan correctos por
+// construccion — que es lo que convierte "agregar un provider" en un cambio
+// localizado en vez de una caceria por seis archivos.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const codex_agent_1 = require("./codex-agent");
+const cursor_mdc_1 = require("./cursor-mdc");
+const copilot_instructions_1 = require("./copilot-instructions");
 /** Extension que el renderer estampa sobre el nombre base, o `null` cuando el
  *  artefacto se instala con el nombre tal cual (renderer `link`). */
 const RENDERER_EXTENSION = {
@@ -61,3 +93,35 @@ function rendererExtension(renderer) {
 function rendererIntegrityMarker(renderer) {
     return RENDERER_INTEGRITY_MARKER[renderer];
 }
+/**
+ * Contenido que `renderer` produce AHORA a partir de `sourcePath`, o `null` para `link`
+ * (no genera nada: instala el artefacto tal cual).
+ *
+ * Es la tercera cosa que un renderer tiene que declarar, junto con su extension y su
+ * marcador — y por eso vive en esta tabla. El dispatch `renderer id → funcion` estaba
+ * escrito DOS veces dentro de `install-transaction.ts` (una en `validate`, otra en
+ * `stage`), y agregar un consumidor mas —el chequeo de frescura del diagnostico— habria
+ * hecho tres. Es exactamente la duplicacion que el comentario de arriba de este modulo
+ * describe como el bug que costo una release.
+ *
+ * Puro: lee la fuente y devuelve texto. No escribe nada, asi que sirve igual para
+ * instalar, para validar antes de instalar, y para preguntar "¿lo instalado sigue
+ * coincidiendo con la fuente?".
+ */
+function renderArtifact(renderer, sourcePath) {
+    switch (renderer) {
+        case 'link':
+            return null;
+        case 'codex-agent-toml':
+            return (0, codex_agent_1.renderCodexAgent)(fs_1.default.readFileSync(sourcePath, 'utf8'));
+        case 'cursor-mdc':
+            return (0, cursor_mdc_1.renderCursorMdc)(readSkillMd(sourcePath));
+        case 'copilot-instructions':
+            return (0, copilot_instructions_1.renderCopilotInstructions)(readSkillMd(sourcePath));
+    }
+}
+/** Las skills se rinden desde el `SKILL.md` de su directorio; los agentes de Codex,
+ *  desde el archivo directo. La diferencia la sabe cada rama de `renderArtifact`. */
+function readSkillMd(sourceDir) {
+    return fs_1.default.readFileSync(path_1.default.join(sourceDir, 'SKILL.md'), 'utf8');
+}

package/dist/src/core/update-check.js

@@ -83,7 +83,11 @@ function maybeNotifyUpdate(opts) {
     const spawnWorker = opts?.spawnWorker ?? spawnRefreshWorker;
     const cache = readUpdateCache();
     if (cache?.latest && isNewer(cache.latest, (0, cli_version_1.cliVersion)())) {
-        console.log(picocolors_1.default.dim(`\n⬆ awm v${cache.latest} available → npm i -g ${cli_version_1.CLI_PACKAGE_NAME}`));
+        // stderr, NO stdout. Este aviso se imprime al final de CUALQUIER comando, asi
+        // que en stdout se mezclaba con la salida de `--json` y rompia a cualquiera que
+        // parsee: `awm doctor --json | jq` fallaba con un SyntaxError que no menciona la
+        // causa. stdout es la interfaz de maquina; los avisos al humano van por stderr.
+        process.stderr.write(picocolors_1.default.dim(`\n⬆ awm v${cache.latest} available → npm i -g ${cli_version_1.CLI_PACKAGE_NAME}\n`));
     }
     if (!cache || now - cache.lastCheck > TTL_MS)
         spawnWorker();

package/dist/tests/core/diagnostics/provider-tier.test.js

@@ -244,6 +244,44 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
         expect(skillsCheck?.detail).toBeUndefined();
         fs_1.default.rmSync(content, { recursive: true, force: true });
     });
+    it('a rendered file that no longer matches its registry source is reported stale', () => {
+        // El caso que C4 realmente pedia. Un symlink apunta al registry, asi que
+        // `awm update` lo actualiza solo — por eso claude-code/codex/opencode nunca
+        // quedan viejos. Un `.mdc` es un archivo GENERADO: se queda con el contenido de
+        // la version anterior hasta que alguien corra `awm sync`, y nada lo decia.
+        const source = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-stale-src-'));
+        fs_1.default.mkdirSync(path_1.default.join(source, 'using-awm'), { recursive: true });
+        const skillMd = path_1.default.join(source, 'using-awm', 'SKILL.md');
+        fs_1.default.writeFileSync(skillMd, '---\nname: using-awm\ndescription: original\n---\n\nCuerpo v1.\n');
+        const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
+        fs_1.default.mkdirSync(rulesDir, { recursive: true });
+        const target = path_1.default.join(rulesDir, 'using-awm.mdc');
+        const { renderArtifact } = require('../../../src/core/renderers/registry');
+        fs_1.default.writeFileSync(target, renderArtifact('cursor-mdc', path_1.default.join(source, 'using-awm')));
+        const stateDir = path_1.default.join(tmpHome, '.awm', 'state');
+        fs_1.default.mkdirSync(stateDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(stateDir, 'artifacts.json'), JSON.stringify([{
+                name: 'using-awm', type: 'skill', scope: 'global',
+                targetPath: target, sourcePath: path_1.default.join(source, 'using-awm'),
+                renderer: 'cursor-mdc', owners: ['cursor'],
+            }]));
+        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        // Recien instalado: coincide con su fuente.
+        const fresh = gatherProviderChecks(['cursor'], scanSkills)[0]
+            .checks.find((c) => c.id === 'skills.global');
+        expect(fresh?.state).toBe('supported');
+        // `awm update` trae una version nueva de la skill upstream.
+        fs_1.default.writeFileSync(skillMd, '---\nname: using-awm\ndescription: original\n---\n\nCuerpo v2, cambiado upstream.\n');
+        const stale = gatherProviderChecks(['cursor'], scanSkills)[0]
+            .checks.find((c) => c.id === 'skills.global');
+        expect(stale?.state).toBe('stale');
+        expect(stale?.detail).toContain('using-awm.mdc');
+        // El remedio depende del alcance, y se midio: `awm update` reconcilia los
+        // artefactos de maquina; `awm sync`, los que declara el profile del proyecto.
+        expect(stale?.remediationCode).toBe('awm-update');
+        fs_1.default.rmSync(source, { recursive: true, force: true });
+    });
     it('non-link renderer with an empty/missing dir reports absent, not a false healthy', () => {
         const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');

package/dist/tests/core/profile.test.js

@@ -100,11 +100,18 @@ describe('ensureSkillsGitignored', () => {
     });
 });
 describe('shouldRecordExtension', () => {
-    it('records only project-scope bundles installed locally', () => {
+    it('no registra nada instalado a nivel maquina, sea cual sea el bundle', () => {
         expect((0, profile_1.shouldRecordExtension)('project', 'local')).toBe(true);
         expect((0, profile_1.shouldRecordExtension)('project', 'global')).toBe(false);
         expect((0, profile_1.shouldRecordExtension)('baseline', 'global')).toBe(false);
-        expect((0, profile_1.shouldRecordExtension)('baseline', 'local')).toBe(false);
         expect((0, profile_1.shouldRecordExtension)('ambient', 'global')).toBe(false);
     });
+    it('records a BASELINE bundle too when it was installed with --scope local', () => {
+        // Antes devolvia false, y esos artefactos quedaban fuera del profile: `awm sync`
+        // reconcilia lo que el profile declara, asi que nadie los refrescaba nunca —
+        // `update` cubre lo global y esto caia en el medio. No es un caso raro:
+        // `awm add dev --scope local` es lo que el playbook AG-03 pide correr.
+        expect((0, profile_1.shouldRecordExtension)('baseline', 'local')).toBe(true);
+        expect((0, profile_1.shouldRecordExtension)('ambient', 'local')).toBe(true);
+    });
 });

package/dist/tests/core/update-check.test.js

@@ -59,12 +59,14 @@ describe('update-check', () => {
     it('maybeNotifyUpdate avisa si el cache trae versión más nueva y NO refresca cache fresco', () => {
         const m = require('../../src/core/update-check');
         m.writeUpdateCache({ lastCheck: 1_000_000, latest: '99.0.0' });
-        const log = jest.spyOn(console, 'log').mockImplementation(() => { });
+        // stderr, no stdout: el aviso sale al final de cualquier comando y en stdout
+        // rompia la salida de `--json`.
+        const err = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
         const spawnWorker = jest.fn();
         m.maybeNotifyUpdate({ now: 1_000_000 + 1000, spawnWorker });
-        expect(log.mock.calls.flat().join('\n')).toContain('99.0.0');
+        expect(err.mock.calls.flat().join('\n')).toContain('99.0.0');
         expect(spawnWorker).not.toHaveBeenCalled();
-        log.mockRestore();
+        err.mockRestore();
     });
     it('cache viejo (>24h) dispara refresh en background', () => {
         const m = require('../../src/core/update-check');
@@ -104,3 +106,32 @@ describe('update-check', () => {
         expect(cache.lastCheck).toBeGreaterThan(0);
     });
 });
+// El aviso de version nueva va por stderr, no por stdout.
+//
+// Se imprime al final de CUALQUIER comando, asi que en stdout se mezclaba con la salida
+// de `--json` y rompia a cualquiera que parsee. Encontrado tropezando con el:
+// `awm doctor --json | node -e 'JSON.parse(...)'` fallaba con un SyntaxError que no
+// menciona la causa. stdout es la interfaz de maquina.
+describe('the update banner never contaminates stdout', () => {
+    it('writes to stderr so `--json` output stays parseable', () => {
+        const stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const log = jest.spyOn(console, 'log').mockImplementation(() => { });
+        try {
+            const { maybeNotifyUpdate } = require('../../src/core/update-check');
+            maybeNotifyUpdate({ spawnWorker: () => { } });
+            const onStdout = stdout.mock.calls.map((c) => String(c[0])).join('')
+                + log.mock.calls.map((c) => String(c[0])).join('');
+            expect(onStdout).not.toContain('available');
+            // Y si habia aviso, salio por stderr — no se perdio, se movio.
+            const emitted = stderr.mock.calls.map((c) => String(c[0])).join('');
+            if (emitted.length > 0)
+                expect(emitted).toContain('available');
+        }
+        finally {
+            stdout.mockRestore();
+            stderr.mockRestore();
+            log.mockRestore();
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "6.1.2",
+  "version": "6.2.1",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"