agentic-workflow-manager 6.1.0 → 6.1.2

package/dist/src/commands/context-budget/budget.js

@@ -99,6 +99,19 @@ function checkBudget(cwd) {
     const config = readConfig(cwd);
     if (!config) {
         const { total, breakdown } = measure(cwd, exports.DEFAULT_FILES);
+        // Fijar sobre CERO archivos es una trampa, no una linea base.
+        //
+        // En un proyecto recien inicializado ninguno de los tres existe todavia: los
+        // escribe una sesion de agente, y `awm init` los reporta como pasos `pending`.
+        // El 0KB no es un error de medicion — no hay nada que medir. Pero dejar
+        // `maxBytes: 0` en disco hace que la corrida SIGUIENTE, apenas el agente escribe
+        // AGENTS.md (el flujo documentado), reporte "excedido". Una alarma que siempre
+        // suena se aprende a ignorar, y ahi se pierde el gate entero.
+        //
+        // Se reporta y NO se escribe config: el proximo run, ya con contexto, fija bien.
+        if (breakdown.length === 0) {
+            return { status: 'unmeasurable', totalBytes: 0, maxBytes: 0, breakdown };
+        }
         writeConfig(cwd, { files: exports.DEFAULT_FILES, maxBytes: total });
         return { status: 'pinned', totalBytes: total, maxBytes: total, breakdown };
     }

package/dist/src/commands/context-budget/index.js

@@ -21,6 +21,14 @@ function exitCodeFor(report) {
 function formatReport(report) {
     const tokens = `~${(0, budget_1.estimateTokens)(report.totalBytes)}k tokens`;
     const breakdown = report.breakdown.map(b => `${b.file} ${KB(b.bytes)}`).join(', ');
+    if (report.status === 'unmeasurable') {
+        // Ni verde ni alarma: no hay nada que reportar todavia, y decir "0KB fijado"
+        // seria afirmar una medicion que no ocurrio.
+        return `${picocolors_1.default.dim('·')}  Nothing to measure yet: none of ${budget_1.DEFAULT_FILES.join(', ')} exists.\n`
+            + `   These are written by an agent session (\`awm init\` lists them as pending).\n`
+            + `   Re-run this once they exist — pinning a budget of 0 would report every\n`
+            + `   later run as over budget.\n`;
+    }
     if (report.status === 'pinned') {
         return `${picocolors_1.default.green('✔')}  Context budget pinned at ${KB(report.totalBytes)} (${tokens} per session).\n`
             + `   ${breakdown}\n`

package/dist/src/commands/hooks/claude.js

@@ -73,7 +73,12 @@ function installClaudeHook(options) {
         settings.hooks = {};
     if (!settings.hooks[config.eventName])
         settings.hooks[config.eventName] = [];
-    const entries = settings.hooks[config.eventName];
+    // Misma poda que en codex.ts: restos nuestros apuntando a un AWM_HOME ya borrado.
+    // `settings.hooks[eventName]` se reasigna porque el objeto se serializa entero abajo.
+    const entries = settings.hooks[config.eventName]
+        .filter((e) => !(0, shared_1.isDeadAwmHookEntry)(e, config.matcher, 'run-hook.cmd', config.scriptsDir));
+    const pruned = settings.hooks[config.eventName].length !== entries.length;
+    settings.hooks[config.eventName] = entries;
     const awmEntryIdx = entries.findIndex((e) => isAwmEntry(e, config.scriptsDir, config.matcher));
     const newEntry = {
         matcher: config.matcher,
@@ -85,7 +90,9 @@ function installClaudeHook(options) {
     };
     let status;
     if (awmEntryIdx >= 0) {
-        if (JSON.stringify(entries[awmEntryIdx]) === JSON.stringify(newEntry)) {
+        // Igual que en codex.ts: si la poda saco algo, hay que escribir aunque nuestra
+        // entrada ya este identica — si no, la limpieza se calcula y se tira.
+        if (!pruned && JSON.stringify(entries[awmEntryIdx]) === JSON.stringify(newEntry)) {
             return { status: 'already-up-to-date', scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath: null };
         }
         entries[awmEntryIdx] = newEntry;

package/dist/src/commands/hooks/codex.js

@@ -56,13 +56,21 @@ function installCodexHook(options) {
     const hooks = current.hooks && typeof current.hooks === 'object'
         ? current.hooks
         : {};
-    const entries = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    const raw = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    // Se podan primero las entradas nuestras que apuntan a un script inexistente: son
+    // restos de otro AWM_HOME ya borrado, y el agente las intenta ejecutar cada sesion.
+    // Una instalacion paralela VIVA no se toca — su script existe. Ver isDeadAwmHookEntry.
+    const entries = raw.filter((entry) => !(0, shared_1.isDeadAwmHookEntry)(entry, codexMatcher(), 'session-start', config.scriptsDir));
     const matches = entries.filter((entry) => isAwmCodexEntry(entry, config.scriptsDir));
     if (matches.length > 1) {
         throw new Error('multiple AWM SessionStart entries in Codex hooks.json');
     }
     const newEntry = awmCodexEntry(config.scriptsDir);
-    if (matches.length === 1 && JSON.stringify(matches[0]) === JSON.stringify(newEntry)) {
+    // `pruned` gana sobre el early-return: si se saco basura hay que ESCRIBIRLA, aunque
+    // nuestra entrada ya este identica. Sin esto la poda se calculaba y se tiraba, y el
+    // archivo quedaba igual — lo detecto su propio test.
+    const pruned = raw.length !== entries.length;
+    if (!pruned && matches.length === 1 && JSON.stringify(matches[0]) === JSON.stringify(newEntry)) {
         return { status: 'already-up-to-date', scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath: null };
     }
     const nextEntries = matches.length === 1

package/dist/src/commands/hooks/shared.js

@@ -14,6 +14,7 @@ exports.backupManagedFile = backupManagedFile;
 exports.readStrictJson = readStrictJson;
 exports.checkExecutable = checkExecutable;
 exports.checkFile = checkFile;
+exports.isDeadAwmHookEntry = isDeadAwmHookEntry;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const paths_1 = require("../../core/paths");
@@ -110,3 +111,44 @@ function checkFile(file) {
         return { ok: false, detail: `broken link: ${file}` };
     }
 }
+/**
+ * Entradas de hook con NUESTRA forma cuyo script ya no existe en disco.
+ *
+ * `awm init` reconoce como propia solo la entrada que apunta al `AWM_HOME` actual, asi
+ * que instalar con otro `AWM_HOME` AGREGA una segunda en vez de reemplazar. Una corrida
+ * de playbook aislada deja en el archivo real una entrada permanente hacia un directorio
+ * temporal ya borrado, y el agente intenta ejecutarla en cada sesion, para siempre.
+ * Observado en una corrida real: `~/.codex/hooks.json` con dos entradas de AWM.
+ *
+ * Tres condiciones, a proposito — es el archivo de configuracion DEL USUARIO y no se le
+ * borran lineas por parecido vago:
+ *   1. el `matcher` es exactamente el nuestro,
+ *   2. el ejecutable se llama como el script que AWM instala, y
+ *   3. esa ruta NO existe.
+ *
+ * Una instalacion paralela viva no cumple (3), asi que sobrevive intacta. Lo unico que
+ * se poda es basura que AWM misma dejo y que ya no puede funcionar.
+ */
+function isDeadAwmHookEntry(entry, matcher, scriptBasename, currentScriptsDir) {
+    const e = entry;
+    if (e?.matcher !== matcher || !Array.isArray(e.hooks))
+        return false;
+    return e.hooks.some((h) => {
+        const command = h?.command;
+        if (typeof command !== 'string' || command.length === 0)
+            return false;
+        // Claude invoca `<ruta>/run-hook.cmd session-start`: el ejecutable es el primer
+        // token. Codex invoca la ruta pelada. Partir por espacio cubre las dos formas.
+        const executable = command.split(' ')[0];
+        if (path_1.default.basename(executable) !== scriptBasename)
+            return false;
+        // La entrada del AWM_HOME ACTUAL nunca es basura, aunque el script todavia no
+        // este en disco: en una instalacion nueva el archivo aparece unos pasos despues.
+        // Sin esta guarda, un `hooks.json` con dos entradas duplicadas del home actual se
+        // podaba entero y el guard de duplicados (R17) dejaba de dispararse — lo detecto
+        // su propio test al agregar la poda.
+        if (path_1.default.dirname(executable) === currentScriptsDir)
+            return false;
+        return !fs_1.default.existsSync(executable);
+    });
+}

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

@@ -60,13 +60,13 @@ function binaryVersionCheck(agent) {
  *  `dir` is null — i.e. the provider has no global skill discovery mechanism at all
  *  (today: Copilot, see `globalUnsupportedReason` in providers/index.ts).
  *
- *  `renderer` gates which verification is possible: `classifySkillLinks` (via `integrity`)
- *  only ever sees symlinks — `if (!lst.isSymbolicLink()) continue;` — so for a rendered
- *  format (`cursor-mdc`, `copilot-instructions`) it scans a directory of real files and
- *  finds nothing, which would make `broken` silently read 0 regardless of whether the
- *  rendered files are actually well-formed. Reporting `'healthy'` from a scan that
- *  structurally can't see the files it's supposed to check would be a false green, so for
- *  any non-`'link'` renderer this reports presence only, honestly, via `detail`. */
+ *  `renderer` parte la verificacion en dos caminos distintos porque los artefactos son
+ *  distintos: `classifySkillLinks` solo ve symlinks — `if (!lst.isSymbolicLink()) continue;`
+ *  — asi que sobre un directorio de archivos renderizados no encuentra nada. Durante un
+ *  tiempo esa rama reporto SOLO presencia, y lo decia en el `detail` para no fingir una
+ *  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) {
     if (dir === null)
         return null;
@@ -88,23 +88,37 @@ function skillsGlobalCheck(dir, owners, integrity, renderer) {
         // Require at least one entry with the extension this renderer actually produces,
         // not just ANY file — a directory non-empty only because of the user's own
         // pre-existing, unrelated rule/instructions file must not read as "AWM installed".
-        // Still not full integrity verification (a stray file with the right extension but
-        // wrong content still passes) — that residual gap is the same honest tradeoff this
-        // function's doc comment already accepts for the non-`'link'` branch generally.
         // `rendererExtension` (core/renderers/registry.ts) is the ONE table mapping a
         // renderer to the file it produces. This site used to keep its own partial copy —
         // the fourth such copy in the codebase, and the exact drift that made a rendered
         // artifact invisible to the "is it installed" check for a whole release. A new
         // renderer must not be able to be added without this reading it.
         const ext = (0, registry_1.rendererExtension)(renderer);
-        const present = ext ? entries.some((e) => e.endsWith(ext)) : entries.length > 0;
+        const rendered = ext ? entries.filter((e) => e.endsWith(ext)) : entries;
+        const present = rendered.length > 0;
+        if (!present) {
+            return {
+                id: 'skills.global', state: 'absent', target: dir,
+                owners: owners.length > 1 ? owners : undefined,
+                remediationCode: 'awm-init',
+            };
+        }
+        // Ya no se reporta "content integrity not verified": AHORA se verifica.
+        // 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);
         return {
             id: 'skills.global',
-            state: present ? 'supported' : 'absent',
+            state: corrupt.length > 0 ? 'broken' : 'supported',
             target: dir,
             owners: owners.length > 1 ? owners : undefined,
-            detail: present ? 'rendered install — content integrity not verified' : undefined,
-            remediationCode: present ? undefined : 'awm-init',
+            detail: corrupt.length > 0
+                ? `${corrupt.length} rendered file(s) missing their expected content (${corrupt.slice(0, 3).join(', ')})`
+                : 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;
@@ -153,21 +167,29 @@ function skillsGlobalCheck(dir, owners, integrity, renderer) {
             : broken > 0 ? 'repair-global-skills' : undefined,
     };
 }
-/** R8: verify the Codex `.toml` agents this run's renderer would have produced still parse. */
-function tomlAgentsHealthy(dir, entries) {
-    const tomls = entries.filter((e) => e.endsWith('.toml'));
-    const broken = tomls.filter((file) => {
+/**
+ * Archivos renderizados cuyo contenido ya no es lo que el renderer escribe.
+ *
+ * El marcador sale de `rendererIntegrityMarker` — la MISMA tabla que da la extension —
+ * y no de una copia local. Antes solo `codex-agent-toml` tenia esta verificacion, con su
+ * marcador horneado en esta funcion: el tercer renderer en agregarse habria pasado sin
+ * verificar y nadie se habria enterado.
+ *
+ * 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 corruptRendered(dir, files, renderer) {
+    const marker = (0, registry_1.rendererIntegrityMarker)(renderer);
+    if (marker === null)
+        return [];
+    return files.filter((file) => {
         try {
-            const content = fs_1.default.readFileSync(path_1.default.join(dir, file), 'utf8');
-            // renderCodexAgent (Task 4) always emits this key — its absence means the
-            // file was hand-edited or truncated, not a shape `awm` would have written.
-            return !content.includes('developer_instructions = ');
+            return !fs_1.default.readFileSync(path_1.default.join(dir, file), 'utf8').includes(marker);
         }
         catch {
             return true;
         }
-    }).length;
-    return { broken };
+    });
 }
 /**
  * Returns `null` when a check doesn't structurally apply to `agent` (e.g. Antigravity
@@ -255,7 +277,10 @@ function agentsNativeCheck(agent) {
     if (entries.length === 0)
         return null;
     if (provider.agent.renderer === 'codex-agent-toml') {
-        const { broken } = tomlAgentsHealthy(dir, entries);
+        // La extension sale de la tabla, no de un literal: escribir '.toml' aca fue
+        // exactamente lo que el guard estructural existe para detener, y lo detuvo.
+        const tomlExt = (0, registry_1.rendererExtension)('codex-agent-toml');
+        const broken = corruptRendered(dir, entries.filter((e) => e.endsWith(tomlExt)), 'codex-agent-toml').length;
         return {
             id: 'agents.native',
             state: broken > 0 ? 'broken' : 'healthy',

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderedFilename = renderedFilename;
 exports.rendererExtension = rendererExtension;
+exports.rendererIntegrityMarker = rendererIntegrityMarker;
 /** 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 = {
@@ -10,6 +11,26 @@ const RENDERER_EXTENSION = {
     'cursor-mdc': '.mdc',
     'copilot-instructions': '.instructions.md',
 };
+/**
+ * Cadena que el renderer SIEMPRE estampa en lo que produce, y que por lo tanto
+ * distingue "el archivo existe" de "el archivo sigue siendo lo que escribimos".
+ *
+ * Vive en esta tabla, al lado de la extension, por la misma razon que la extension:
+ * son los dos hechos que un renderer nuevo tiene que declarar, y tenerlos juntos hace
+ * imposible agregar uno y olvidarse del segundo. `codex-agent-toml` ya tenia su marcador
+ * — horneado dentro de `tomlAgentsHealthy` en provider-checks.ts — y era el UNICO de los
+ * tres renderers con verificacion de contenido. Los otros dos comprobaban presencia y
+ * extension: un archivo correcto por fuera y vacio o truncado por dentro pasaba como sano.
+ *
+ * `null` en `link`: ahi la integridad la responde el clasificador de symlinks, que
+ * ademas distingue colgante de usurpado (D-007). Un marcador de texto no aplica.
+ */
+const RENDERER_INTEGRITY_MARKER = {
+    link: null,
+    'codex-agent-toml': 'developer_instructions = ',
+    'cursor-mdc': 'alwaysApply:',
+    'copilot-instructions': 'applyTo:',
+};
 /** `.md` es la unica extension que un `installName` de artefacto puede traer.
  *  Deliberadamente NO se usa `path.parse().name`: eso corta desde el ULTIMO
  *  punto, asi que un skill llamado `v1.2-migration` se truncaria a `v1`,
@@ -35,3 +56,8 @@ function renderedFilename(installName, renderer) {
 function rendererExtension(renderer) {
     return RENDERER_EXTENSION[renderer];
 }
+/** Marcador de integridad del renderer, o `null` cuando no aplica (`link`).
+ *  Ver `RENDERER_INTEGRITY_MARKER`. */
+function rendererIntegrityMarker(renderer) {
+    return RENDERER_INTEGRITY_MARKER[renderer];
+}

package/dist/tests/commands/context-budget/budget.test.js

@@ -8,6 +8,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const budget_1 = require("../../../src/commands/context-budget/budget");
 const context_budget_1 = require("../../../src/commands/context-budget");
+const tmp_1 = require("../../support/tmp");
 function project(files) {
     // CLAUDE.md: no test may reach the real ~/.awm. Everything here is a tmpdir.
     const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-budget-'));
@@ -98,3 +99,38 @@ describe('reporting', () => {
         expect(out).toMatch(/~5[0-9]k tokens/);
     });
 });
+// Fijar sobre cero archivos garantiza una falsa alarma en la corrida siguiente.
+//
+// `context-budget` mide AGENTS.md / CONSTITUTION.md / CLAUDE.md. En un proyecto recien
+// inicializado NINGUNO existe: los escribe una sesion de agente, y `awm init` los reporta
+// como pasos `pending`. El 0KB no es un error de medicion — no hay nada que medir. El
+// problema es FIJAR sobre eso: apenas el agente escribe AGENTS.md, que es el flujo
+// documentado, el comando reporta "excedido". Una alarma que siempre suena se aprende a
+// ignorar. Ver issue #56.
+describe('pinning refuses to happen when there is nothing to measure', () => {
+    let cwd;
+    beforeEach(() => { cwd = (0, tmp_1.mkCanonicalTmpDir)('awm-budget-zero-'); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    it('does not pin a budget on a project whose context files do not exist yet', () => {
+        const report = (0, budget_1.checkBudget)(cwd);
+        expect(report.status).toBe('unmeasurable');
+        expect(report.totalBytes).toBe(0);
+        // Lo que importa: NO deja config. Un `maxBytes: 0` en disco es la trampa.
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, budget_1.CONFIG_FILE))).toBe(false);
+    });
+    it('the very next run, after the agent writes AGENTS.md, is not "over budget"', () => {
+        (0, budget_1.checkBudget)(cwd); // primer intento: nada que medir
+        fs_1.default.writeFileSync(path_1.default.join(cwd, 'AGENTS.md'), 'x'.repeat(3000));
+        const report = (0, budget_1.checkBudget)(cwd);
+        // Este es el bug entero: antes daba 'over' — 3KB contra un maximo de 0.
+        expect(report.status).toBe('pinned');
+        expect(report.maxBytes).toBe(3000);
+    });
+    it('still pins normally when at least one context file exists', () => {
+        fs_1.default.writeFileSync(path_1.default.join(cwd, 'CLAUDE.md'), 'y'.repeat(500));
+        const report = (0, budget_1.checkBudget)(cwd);
+        expect(report.status).toBe('pinned');
+        expect(report.maxBytes).toBe(500);
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, budget_1.CONFIG_FILE))).toBe(true);
+    });
+});

package/dist/tests/commands/hooks/codex.test.js

@@ -248,6 +248,60 @@ describe('installHook / computeHookStatus / uninstallHook — Codex adapter', ()
         expect(result.status).toBe('not-installed');
         expect(result.backupPath).toBeNull();
     });
+    // Restos de otro AWM_HOME: se podan, pero solo si estan MUERTOS.
+    //
+    // `awm init` reconoce como propia solo la entrada del AWM_HOME actual, asi que instalar
+    // con otro AGREGA una segunda. Una corrida de playbook aislada deja en el archivo real
+    // una entrada permanente hacia un directorio temporal ya borrado, y el agente la intenta
+    // ejecutar cada sesion. Observado: `~/.codex/hooks.json` con dos entradas de AWM. Ver
+    // backlog §C2.
+    describe('stale AWM entries from another AWM_HOME are pruned, live ones are not', () => {
+        /** Una entrada con nuestra forma apuntando a `scriptPath`. */
+        function entryFor(scriptPath) {
+            return {
+                matcher: 'startup|resume|clear|compact',
+                hooks: [{ type: 'command', command: scriptPath, statusMessage: 'Loading AWM session state' }],
+            };
+        }
+        it('drops an entry whose script no longer exists', () => {
+            const { isDeadAwmHookEntry } = require('../../../src/commands/hooks/shared');
+            const dead = entryFor('/tmp/awm-home-that-was-deleted/hooks/codex/session-start');
+            expect(isDeadAwmHookEntry(dead, 'startup|resume|clear|compact', 'session-start', codexScriptsDir)).toBe(true);
+        });
+        it('keeps a parallel install whose script DOES exist', () => {
+            // Es la diferencia entre limpiar basura propia y romperle la instalacion a alguien.
+            const { isDeadAwmHookEntry } = require('../../../src/commands/hooks/shared');
+            const alive = entryFor(path_1.default.join(codexScriptsDir, 'session-start'));
+            fs_1.default.mkdirSync(codexScriptsDir, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'session-start'), '#!/bin/sh\n', { mode: 0o755 });
+            expect(isDeadAwmHookEntry(alive, 'startup|resume|clear|compact', 'session-start', codexScriptsDir)).toBe(false);
+        });
+        it('leaves a foreign hook alone even when its path is dead', () => {
+            // Mismo matcher, ruta muerta, pero NO es nuestro script: no se toca.
+            const { isDeadAwmHookEntry } = require('../../../src/commands/hooks/shared');
+            const foreign = entryFor('/tmp/someone-elses/my-own-hook');
+            expect(isDeadAwmHookEntry(foreign, 'startup|resume|clear|compact', 'session-start', codexScriptsDir)).toBe(false);
+        });
+        it('install removes the stale entry instead of accumulating a second one', () => {
+            installCodexFixture({ heartbeat: false });
+            const hooksJson = path_1.default.join(tmpHome, '.codex', 'hooks.json');
+            const current = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf-8'));
+            // Simular la corrida anterior con otro AWM_HOME, ya borrado.
+            current.hooks.SessionStart.unshift(entryFor('/tmp/awm-e2e-gone/hooks/codex/session-start'));
+            fs_1.default.writeFileSync(hooksJson, JSON.stringify(current, null, 2));
+            expect(JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf-8')).hooks.SessionStart).toHaveLength(2);
+            writeRegistry();
+            const { installHook } = require('../../../src/commands/hooks/install');
+            installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'copy' });
+            const after = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf-8')).hooks.SessionStart;
+            expect(after).toHaveLength(1);
+            // Sobre la ESTRUCTURA, no sobre el JSON serializado: en Windows las barras
+            // invertidas van escapadas dentro del string, asi que un `toContain(tmpHome)`
+            // compara `C:\Users\...` contra `C:\\Users\\...` y falla sobre un producto
+            // que se comporta bien. Paso en CI — `platform-property-assumed-universal`.
+            expect(after[0].hooks[0].command).toBe(path_1.default.join(codexScriptsDir, 'session-start'));
+        });
+    });
 });
 // El remedio tiene que ser ejecutable, no un codigo.
 //

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

@@ -183,7 +183,24 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
         const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
         expect(skillsCheck?.state).not.toBe('healthy');
         expect(skillsCheck?.state).toBe('supported');
-        expect(skillsCheck?.detail).toContain('not verified');
+        // Antes decia 'content integrity not verified' — honesto entonces, porque no se
+        // verificaba. Ahora SI se verifica, y este archivo tiene su marcador, asi que no
+        // hay nada que reportar.
+        expect(skillsCheck?.detail).toBeUndefined();
+    });
+    it('a rendered file with the right extension but a truncated body is reported broken', () => {
+        // El hueco que cerraba C3: presencia + extension dejaba pasar un archivo correcto
+        // por fuera y vacio por dentro. El agente cargaba nada y doctor decia que si.
+        const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
+        fs_1.default.mkdirSync(rulesDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(rulesDir, 'development-process.mdc'), '---\ndescription: x\n');
+        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        const facts = gatherProviderChecks(['cursor'], scanSkills);
+        const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
+        expect(skillsCheck?.state).toBe('broken');
+        expect(skillsCheck?.detail).toContain('development-process.mdc');
+        expect(skillsCheck?.remediationCode).toBe('reinstall-rendered-artifacts');
     });
     it('Gap B — non-link renderer (cursor-mdc) against REAL renderer/pipeline output, not a hand-written approximation', () => {
         // The test above hand-writes a `.mdc` file whose frontmatter shape is only an
@@ -221,7 +238,10 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
         const facts = gatherProviderChecks(['cursor'], scanSkills);
         const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
         expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'supported', target: rulesDir });
-        expect(skillsCheck?.detail).toContain('not verified');
+        // La verificacion de contenido corre sobre la salida REAL del renderer, no sobre
+        // una aproximacion escrita a mano: si el marcador declarado en la tabla no
+        // coincidiera con lo que el renderer emite de verdad, este test lo detectaria.
+        expect(skillsCheck?.detail).toBeUndefined();
         fs_1.default.rmSync(content, { recursive: true, force: true });
     });
     it('non-link renderer with an empty/missing dir reports absent, not a false healthy', () => {

package/package.json

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