agentic-workflow-manager 3.13.5 → 3.13.7

package/dist/tests/commands/sensors/install-settings-safety.test.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: `installSensorHook` leia `~/.claude/settings.json` con
+// `try { JSON.parse(...) } catch { return {} }` y despues escribia ese `{}` de
+// vuelta — o sea, ante un JSON malformado (una coma de mas, el error de edicion
+// a mano mas comun) BORRABA el archivo entero del usuario y reportaba exito.
+//
+// Verificado destruyendo `model`, `permissions` y el propio hook SessionStart de
+// AWM. El escritor hermano (`installClaudeHook`) ya se negaba correctamente ante
+// el mismo archivo: tres escritores del mismo archivo, tres niveles de dureza.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('installSensorHook: nunca destruye settings.json del usuario', () => {
+    let home;
+    let settingsPath;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sensor-hook-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+        fs_1.default.mkdirSync(path_1.default.join(home, '.claude'), { recursive: true });
+        settingsPath = path_1.default.join(home, '.claude', 'settings.json');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    });
+    it('ante JSON malformado NO reescribe el archivo — falla en vez de destruirlo', () => {
+        // Coma de mas: sintacticamente invalido, semanticamente el archivo real
+        // del usuario con toda su configuracion.
+        const malformed = `{
+  "model": "claude-opus-4",
+  "permissions": { "allow": ["Bash(npm test)"] },
+  "hooks": { "SessionStart": [{ "matcher": "startup", "hooks": [] }] },
+}`;
+        fs_1.default.writeFileSync(settingsPath, malformed);
+        const { installSensorHook } = require('../../../src/commands/sensors/install');
+        const result = (() => {
+            try {
+                return installSensorHook();
+            }
+            catch (e) {
+                return { threw: e };
+            }
+        })();
+        // El contrato es no-destruccion. Que lance o que reporte un fallo son
+        // dos formas aceptables de negarse; escribir sobre el archivo no lo es.
+        const after = fs_1.default.readFileSync(settingsPath, 'utf-8');
+        expect(after).toBe(malformed);
+        expect(after).toContain('"model"');
+        expect(after).toContain('"permissions"');
+        expect(JSON.stringify(result)).not.toContain('"status":"installed"');
+    });
+    it('sobre un settings.json valido, preserva las claves del usuario e instala el hook', () => {
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify({
+            model: 'claude-opus-4',
+            permissions: { allow: ['Bash(npm test)'] },
+        }, null, 2));
+        const { installSensorHook } = require('../../../src/commands/sensors/install');
+        installSensorHook();
+        const after = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+        expect(after.model).toBe('claude-opus-4');
+        expect(after.permissions).toEqual({ allow: ['Bash(npm test)'] });
+        expect(after.hooks).toBeDefined();
+    });
+    it('sin settings.json previo, lo crea sin romper nada', () => {
+        const { installSensorHook } = require('../../../src/commands/sensors/install');
+        expect(() => installSensorHook()).not.toThrow();
+        expect(fs_1.default.existsSync(settingsPath)).toBe(true);
+        expect(() => JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'))).not.toThrow();
+    });
+});

package/dist/tests/commands/sensors/run.test.js

@@ -280,38 +280,12 @@ describe('runSensors — not_certified + auto-discovery', () => {
         expect(out.sensors.length).toBe(1);
     });
 });
-describe('reconcilePack', () => {
-    // Build a minimal fake registry in a tmpdir (registry/ no longer lives in this repo —
-    // content lives in awm-baseline-registry / awm-documentation-registry).
-    let FAKE_REGISTRY;
-    beforeAll(() => {
-        FAKE_REGISTRY = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-fake-reg-'));
-        const jstsPackDir = path_1.default.join(FAKE_REGISTRY, 'sensor-packs', 'js-ts');
-        const genericPackDir = path_1.default.join(FAKE_REGISTRY, 'sensor-packs', 'generic');
-        fs_1.default.mkdirSync(jstsPackDir, { recursive: true });
-        fs_1.default.mkdirSync(genericPackDir, { recursive: true });
-        // Minimal pack.json matching what the real js-ts pack ships
-        fs_1.default.writeFileSync(path_1.default.join(jstsPackDir, 'pack.json'), JSON.stringify({
-            name: 'js-ts',
-            description: 'JavaScript/TypeScript sensor pack (test fixture)',
-            sensors: {
-                typecheck: { defaultCmd: 'npx tsc --noEmit', fast: true },
-                lint: { defaultCmd: 'npx eslint . --format json', fast: true },
-                security: { defaultCmd: 'semgrep --config .semgrep.awm.yml --json .', fast: false },
-                mutation: { enabled: false },
-            },
-        }));
-        fs_1.default.writeFileSync(path_1.default.join(genericPackDir, 'pack.json'), JSON.stringify({
-            name: 'generic',
-            description: 'Generic sensor pack (test fixture)',
-            sensors: {
-                security: { defaultCmd: 'semgrep .', fast: false },
-            },
-        }));
-    });
-    afterAll(() => { fs_1.default.rmSync(FAKE_REGISTRY, { recursive: true, force: true }); });
+describe('detectPackDrift', () => {
+    // Pure detection: it reads the tree and reports. It does NOT rebuild the manifest
+    // and does NOT consult a registry — see run-is-read-only.test.ts for why the
+    // rebuild it used to do (`reconcilePack`) was removed.
     function tmpProject(pack, withPackageJson) {
-        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-reconcile-'));
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-drift-'));
         fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), JSON.stringify({ pack, sensors: pack === 'generic'
                 ? { security: { cmd: 'semgrep .', fast: false } }
@@ -320,46 +294,45 @@ describe('reconcilePack', () => {
             fs_1.default.writeFileSync(path_1.default.join(dir, 'package.json'), '{}');
         return dir;
     }
-    it('upgrades generic→js-ts when package.json is present', async () => {
-        const { reconcilePack } = require('../../../src/commands/sensors/run');
+    it('reports generic→js-ts drift when package.json is present', () => {
+        const { detectPackDrift } = require('../../../src/commands/sensors/run');
         const dir = tmpProject('generic', true);
         try {
             const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
-            const res = reconcilePack(dir, manifest, FAKE_REGISTRY);
-            expect(res.manifest.pack).toBe('js-ts');
-            expect(res.upgradedFrom).toBe('generic');
-            expect(Object.keys(res.manifest.sensors)).toContain('typecheck');
-            // custom sensor cmd preserved through merge
-            expect(res.manifest.sensors.security?.cmd).toBe('semgrep .');
-            // persisted to disk
+            const res = detectPackDrift(dir, manifest);
+            expect(res.detection.pack).toBe('js-ts');
+            expect(res.drift).toEqual({
+                manifest: 'generic',
+                detected: 'js-ts',
+                remedy: expect.stringContaining('awm sensors init'),
+            });
+            // the manifest on disk is untouched — reporting is not healing
             const onDisk = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
-            expect(onDisk.pack).toBe('js-ts');
+            expect(onDisk.pack).toBe('generic');
         }
         finally {
             fs_1.default.rmSync(dir, { recursive: true });
         }
     });
-    it('is a no-op when pack is already real (idempotent)', async () => {
-        const { reconcilePack } = require('../../../src/commands/sensors/run');
+    it('reports no drift when the pack is already real', () => {
+        const { detectPackDrift } = require('../../../src/commands/sensors/run');
         const dir = tmpProject('js-ts', true);
         try {
             const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
-            const res = reconcilePack(dir, manifest, FAKE_REGISTRY);
-            expect(res.manifest.pack).toBe('js-ts');
-            expect(res.upgradedFrom).toBeUndefined();
+            expect(detectPackDrift(dir, manifest).drift).toBeUndefined();
         }
         finally {
             fs_1.default.rmSync(dir, { recursive: true });
         }
     });
-    it('does not upgrade a truly generic project (no indicators)', async () => {
-        const { reconcilePack } = require('../../../src/commands/sensors/run');
+    it('reports no drift on a truly generic project (no indicators)', () => {
+        const { detectPackDrift } = require('../../../src/commands/sensors/run');
         const dir = tmpProject('generic', false);
         try {
             const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
-            const res = reconcilePack(dir, manifest, FAKE_REGISTRY);
-            expect(res.manifest.pack).toBe('generic');
-            expect(res.upgradedFrom).toBeUndefined();
+            const res = detectPackDrift(dir, manifest);
+            expect(res.detection.pack).toBe('generic');
+            expect(res.drift).toBeUndefined();
         }
         finally {
             fs_1.default.rmSync(dir, { recursive: true });

package/dist/tests/commands/sensors/status-windows.test.js

@@ -6,50 +6,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
-const child_process_1 = require("child_process");
 const status_1 = require("../../../src/commands/sensors/status");
-jest.mock('child_process', () => ({ execSync: jest.fn() }));
-const mockExecSync = child_process_1.execSync;
+// `resolveOnPath` resuelve PATH en proceso (ya no invoca un shell — ver el
+// comentario de seguridad en core/paths.ts). Estos tests controlan un PATH
+// aislado en vez de mockear `execSync`: refleja el mecanismo real y los vuelve
+// deterministas. Lo que se verifica en win32 sigue siendo lo mismo que motivo
+// este archivo: que un shim `.cmd` de npm resuelva (bug real publicado en
+// v3.9.0, donde los sensores quedaban todos "no encontrados" en Windows).
 describe('computeSensorStatus — Windows PATH resolution', () => {
     let tmpDir;
+    let pathDir;
+    let originalPath;
+    let originalPathExt;
     const originalPlatform = process.platform;
     beforeEach(() => {
         tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-win-'));
-        mockExecSync.mockReset();
+        pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-win-path-'));
+        originalPath = process.env.PATH;
+        originalPathExt = process.env.PATHEXT;
+        process.env.PATH = pathDir;
+        process.env.PATHEXT = '.COM;.EXE;.BAT;.CMD';
         Object.defineProperty(process, 'platform', { value: 'win32' });
     });
     afterEach(() => {
-        fs_1.default.rmSync(tmpDir, { recursive: true });
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        if (originalPathExt === undefined)
+            delete process.env.PATHEXT;
+        else
+            process.env.PATHEXT = originalPathExt;
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        fs_1.default.rmSync(pathDir, { recursive: true, force: true });
         Object.defineProperty(process, 'platform', { value: originalPlatform });
     });
-    it('resolves an installed binary on win32 using `where`, not `which`', () => {
+    function writeManifest() {
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
             pack: 'js-ts',
             sensors: { security: { cmd: 'semgrep --json .', fast: false } }
         }));
-        mockExecSync.mockImplementation(((cmd) => {
-            if (cmd.startsWith('where '))
-                return Buffer.from('C:\\tools\\semgrep.exe');
-            throw new Error(`not found: ${cmd}`);
-        }));
+    }
+    it('resuelve un binario instalado en win32 via PATHEXT (incluido un shim .cmd)', () => {
+        writeManifest();
+        // En win32 el usuario escribe `semgrep` y en disco existe `semgrep.cmd`.
+        fs_1.default.writeFileSync(path_1.default.join(pathDir, 'semgrep.cmd'), '@echo off\r\n');
         const result = (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('HEALTHY');
         expect(result.checks.security.ok).toBe(true);
     });
-    it('reports ok:false on win32 when `where` cannot find the binary', () => {
-        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
-            pack: 'js-ts',
-            sensors: { security: { cmd: 'semgrep --json .', fast: false } }
-        }));
-        mockExecSync.mockImplementation(((cmd) => {
-            if (cmd.startsWith('where '))
-                throw new Error(`not found: ${cmd}`);
-            throw new Error(`not found: ${cmd}`);
-        }));
+    it('reporta ok:false en win32 cuando el binario no esta en PATH', () => {
+        writeManifest();
+        // PATH aislado y vacio.
         const result = (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('DEGRADED');
         expect(result.checks.security.ok).toBe(false);
     });
+    it('en win32 no exige bit de ejecucion — un .exe sin permisos POSIX igual resuelve', () => {
+        writeManifest();
+        fs_1.default.writeFileSync(path_1.default.join(pathDir, 'semgrep.exe'), '');
+        fs_1.default.chmodSync(path_1.default.join(pathDir, 'semgrep.exe'), 0o644);
+        expect((0, status_1.computeSensorStatus)(tmpDir).checks.security.ok).toBe(true);
+    });
 });

package/dist/tests/commands/sensors/status.test.js

@@ -6,17 +6,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
-const child_process_1 = require("child_process");
 const status_1 = require("../../../src/commands/sensors/status");
-jest.mock('child_process', () => ({ execSync: jest.fn() }));
-const mockExecSync = child_process_1.execSync;
+// `resolveOnPath` resuelve PATH en proceso (ya no invoca un shell — ver
+// core/paths.ts). Por eso estos tests controlan un PATH aislado en vez de
+// mockear `execSync`: ademas de reflejar el mecanismo real, los vuelve
+// deterministas, que antes no lo eran (el caso "binario ausente" pasaba solo
+// en maquinas donde ese binario realmente no estuviera instalado).
 describe('computeSensorStatus', () => {
     let tmpDir;
+    let pathDir;
+    let originalPath;
     beforeEach(() => {
         tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-'));
-        mockExecSync.mockReset();
+        pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-path-'));
+        originalPath = process.env.PATH;
+        process.env.PATH = pathDir; // PATH vacio salvo lo que cada test instale
     });
-    afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
+    afterEach(() => {
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        fs_1.default.rmSync(pathDir, { recursive: true, force: true });
+    });
+    /** Instala un binario ejecutable real en el PATH aislado del test. */
+    function installOnPath(tool) {
+        const p = path_1.default.join(pathDir, tool);
+        fs_1.default.writeFileSync(p, '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(p, 0o755);
+    }
     it('returns NOT_CONFIGURED when .awm/sensors.json missing', () => {
         const result = (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('NOT_CONFIGURED');
@@ -80,7 +99,7 @@ describe('computeSensorStatus', () => {
             pack: 'js-ts',
             sensors: { security: { cmd: 'semgrep --json .', fast: false } }
         }));
-        mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+        // PATH aislado y vacio => semgrep no resuelve.
         const result = (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('DEGRADED');
         expect(result.checks.security.ok).toBe(false);
@@ -93,17 +112,13 @@ describe('computeSensorStatus', () => {
         afterEach(() => {
             Object.defineProperty(process, 'platform', { value: originalPlatform });
         });
-        it('resolves an installed binary using `command -v`, not `where`', () => {
+        it('resuelve un binario instalado recorriendo PATH, sin invocar un shell', () => {
             fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
             fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
                 pack: 'js-ts',
                 sensors: { security: { cmd: 'semgrep --json .', fast: false } }
             }));
-            mockExecSync.mockImplementation(((cmd) => {
-                if (cmd === 'command -v semgrep')
-                    return Buffer.from('/usr/bin/semgrep');
-                throw new Error(`not found: ${cmd}`);
-            }));
+            installOnPath('semgrep');
             const result = (0, status_1.computeSensorStatus)(tmpDir);
             expect(result.overall).toBe('HEALTHY');
             expect(result.checks.security.ok).toBe(true);

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

@@ -11,6 +11,16 @@ 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, 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/artifact-name-containment.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// SECURITY regression: artifact names taken VERBATIM from a registry's
+// `bundle.json` were joined onto the provider's install directory with no
+// validation and no containment check, so `path.join(dir, name)` escaped the
+// directory entirely:
+//
+//   path.join('~/.claude/skills', '../../.ssh/authorized_keys')
+//     => '~/.ssh/authorized_keys'
+//
+// Impact went well past a stray write. `replaceArtifact` does
+// `fs.rmSync(targetPath, {recursive:true, force:true})` before linking, so a
+// name of `../../.ssh` RECURSIVELY DELETED the user's real ~/.ssh and replaced
+// it with a symlink into the attacker's registry clone. Writing
+// `~/.config/autostart/*.desktop` gives code execution at next login.
+//
+// Reachable from `awm add`, `awm sync`, `awm registry add` and `awm init` —
+// and note that `awm init` auto-installs the first bundle declaring
+// `scope: "baseline"` across ALL roots, so a malicious registry does not even
+// need the user to pick its bundle.
+//
+// Every other registry-facing reader in this codebase already rejects `..` and
+// separators (readRegistriesConfig, readRegistryManifest, readProfile). The
+// bundle path was the one that never got the guard.
+const artifact_name_1 = require("../../src/core/artifact-name");
+describe('assertSafeArtifactName: contencion de nombres provenientes del registry', () => {
+    const TRAVERSAL = [
+        ['padre relativo', '../evil'],
+        ['padre profundo', '../../../../../../tmp/escape'],
+        ['ssh del usuario', '../../.ssh/authorized_keys'],
+        ['separador posix', 'sub/dir'],
+        ['separador windows', 'sub\\dir'],
+        ['absoluto posix', '/etc/passwd'],
+        ['absoluto windows', 'C:\\Windows\\System32\\x'],
+        ['unc windows', '\\\\server\\share'],
+        ['componente punto', '.'],
+        ['componente doble punto', '..'],
+        ['punto embebido', 'a/../b'],
+    ];
+    it.each(TRAVERSAL)('rechaza %s', (_name, candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)(candidate, 'skill')).toThrow(/unsafe|invalid/i);
+    });
+    it.each([
+        ['vacio', ''],
+        ['solo espacios', '   '],
+        ['byte NUL', 'evil\u0000.md'],
+        ['byte de control', 'evil\u0001name'],
+    ])('rechaza %s', (_name, candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+    });
+    it.each([
+        ['CON', 'CON'], ['con minuscula', 'con'], ['con extension', 'CON.md'],
+        ['AUX', 'AUX'], ['NUL', 'NUL'], ['PRN', 'PRN'],
+        ['COM1', 'COM1'], ['LPT1', 'LPT1'],
+    ])('rechaza el nombre reservado de Windows %s', (_name, candidate) => {
+        // Reservados en TODA plataforma a proposito: el registry es contenido
+        // compartido entre equipos, y un nombre que rompe solo en las maquinas
+        // Windows del equipo es peor que uno que se rechaza en todas.
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+    });
+    it.each([
+        ['punto final', 'skill.'],
+        ['espacio final', 'skill '],
+    ])('rechaza %s (Windows los recorta en silencio y cambia el destino)', (_name, candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(false);
+    });
+    it.each([
+        'development-process',
+        'skill_con_guion_bajo',
+        'v1.2-migration',
+        'extract-design-md',
+        'a',
+        'UPPER-case-Mixed',
+        'skill.md',
+    ])('acepta el nombre legitimo %s', (candidate) => {
+        expect((0, artifact_name_1.isSafeArtifactName)(candidate)).toBe(true);
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)(candidate, 'skill')).not.toThrow();
+    });
+    it('el mensaje de error nombra el tipo y el valor ofensivo, para que el operador pueda ubicarlo', () => {
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)('../../.ssh', 'skill'))
+            .toThrow(/skill/);
+        expect(() => (0, artifact_name_1.assertSafeArtifactName)('../../.ssh', 'skill'))
+            .toThrow(/\.\.\/\.\.\/\.ssh/);
+    });
+});

package/dist/tests/core/context/agents-md-single-slot.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: `managed-block.ts` soporta UN bloque gestionado por archivo, y
+// tanto el contexto de cursor/copilot (`inject()`, cuyo destino ES el AGENTS.md
+// del proyecto) como la guia de proyecto de codex (`injectProject()`) apuntan al
+// mismo `<projectRoot>/AGENTS.md`. El que corriera ultimo ganaba:
+//
+//     awm init -a copilot  → AGENTS.md 140 lineas (contexto AWM completo)
+//     awm init -a codex    → AGENTS.md   6 lineas (solo PROJECT_GUIDANCE)
+//     awm init -a copilot  → 140 otra vez ... y asi oscilando
+//
+// Para Copilot ese archivo es su UNICO canal de entrega, asi que un init de
+// codex lo dejaba literalmente sin contexto. El contenido de cursor/copilot es
+// un SUPERCONJUNTO — termina con el mismo PROJECT_GUIDANCE — asi que pisarlo
+// siempre es perder informacion.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const codex_agents_1 = require("../../../src/core/context/strategies/codex-agents");
+const managed_block_1 = require("../../../src/core/context/managed-block");
+const providers_1 = require("../../../src/providers");
+describe('AGENTS.md: un solo slot, dos escritores', () => {
+    let projectRoot;
+    let agentsMd;
+    beforeEach(() => {
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-agentsmd-'));
+        agentsMd = path_1.default.join(projectRoot, 'AGENTS.md');
+    });
+    afterEach(() => fs_1.default.rmSync(projectRoot, { recursive: true, force: true }));
+    const strategy = () => new codex_agents_1.CodexAgentsStrategy();
+    it('injectProject de codex NO pisa un bloque que ya cubre PROJECT_GUIDANCE', () => {
+        // Primero se deja que codex escriba, para capturar su PROJECT_GUIDANCE
+        // sin depender de un export interno.
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        const guidance = (0, managed_block_1.managedBlockBody)(fs_1.default.readFileSync(agentsMd, 'utf-8'));
+        // Ahora se simula lo que dejan cursor/copilot: contexto AWM completo
+        // que TERMINA con esa misma guia — un superconjunto.
+        const rich = `# Contexto AWM completo\n\nmuchas lineas de contexto\n\n${guidance}`;
+        fs_1.default.writeFileSync(agentsMd, `<!-- AWM:START -->\n${rich}\n<!-- AWM:END -->\n`);
+        const before = fs_1.default.readFileSync(agentsMd, 'utf-8');
+        // Un `awm init -a codex` posterior debe dejarlo intacto: antes lo
+        // reemplazaba por las 6 lineas de la guia, y para Copilot ese archivo es
+        // su unico canal de entrega.
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        expect(fs_1.default.readFileSync(agentsMd, 'utf-8')).toBe(before);
+        expect(fs_1.default.readFileSync(agentsMd, 'utf-8')).toContain('muchas lineas de contexto');
+    });
+    it('codex SI escribe la guia cuando el archivo no existe todavia', () => {
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        expect(fs_1.default.existsSync(agentsMd)).toBe(true);
+        expect((0, managed_block_1.managedBlockBody)(fs_1.default.readFileSync(agentsMd, 'utf-8'))).toBeTruthy();
+    });
+    it('codex es idempotente: una segunda pasada no cambia el archivo', () => {
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        const first = fs_1.default.readFileSync(agentsMd, 'utf-8');
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        expect(fs_1.default.readFileSync(agentsMd, 'utf-8')).toBe(first);
+    });
+    it('el contenido que el usuario tiene fuera del bloque gestionado se conserva', () => {
+        fs_1.default.writeFileSync(agentsMd, '# Mis notas\n\nEsto es mio.\n');
+        strategy().injectProject(projectRoot, (0, providers_1.providerFor)('codex'), 'codex');
+        const after = fs_1.default.readFileSync(agentsMd, 'utf-8');
+        expect(after).toContain('# Mis notas');
+        expect(after).toContain('Esto es mio.');
+    });
+});

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

@@ -53,13 +53,13 @@ describe('regenerateGlobalContext', () => {
     it('returns empty when no config-instructions agent has a config file', () => {
         seedRegistry();
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(regenerateGlobalContext()).toEqual([]);
+        expect(regenerateGlobalContext(['opencode'])).toEqual([]);
     });
     it('skips an agent whose config exists but has no AWM sentinel', () => {
         seedRegistry();
         seedOpencode(['docs/rules.md']); // sin el sentinel
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(regenerateGlobalContext(['opencode'])).toEqual([{ agent: 'opencode', action: 'skipped' }]);
         expect(fs_1.default.existsSync(contextPath())).toBe(false); // no se crea el archivo
     });
     it('refreshes a stale agent (sentinel present, materialized file absent) and recreates the file', () => {
@@ -67,7 +67,7 @@ describe('regenerateGlobalContext', () => {
         seedOpencode([contextPath()]); // sentinel presente, pero el archivo no existe → stale
         expect(fs_1.default.existsSync(contextPath())).toBe(false);
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'refreshed' }]);
+        expect(regenerateGlobalContext(['opencode'])).toEqual([{ agent: 'opencode', action: 'refreshed' }]);
         expect(fs_1.default.existsSync(contextPath())).toBe(true);
         expect(fs_1.default.readFileSync(contextPath(), 'utf-8')).toContain('USING-AWM-BODY');
     });
@@ -75,9 +75,9 @@ describe('regenerateGlobalContext', () => {
         seedRegistry();
         seedOpencode([contextPath()]);
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        regenerateGlobalContext(); // 1ª pasada: stale → refreshed, crea el archivo
+        regenerateGlobalContext(['opencode']); // 1ª pasada: stale → refreshed, crea el archivo
         const mtime1 = fs_1.default.statSync(contextPath()).mtimeMs;
-        const second = regenerateGlobalContext(); // 2ª pasada: ya injected → fresh
+        const second = regenerateGlobalContext(['opencode']); // 2ª pasada: ya injected → fresh
         expect(second).toEqual([{ agent: 'opencode', action: 'fresh' }]);
         expect(fs_1.default.statSync(contextPath()).mtimeMs).toBe(mtime1); // archivo intacto
     });
@@ -90,8 +90,8 @@ describe('regenerateGlobalContext', () => {
         fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.com/baseline.git' }], null, 2) + '\n');
         seedOpencode([contextPath()]);
         const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
-        expect(() => regenerateGlobalContext()).not.toThrow();
-        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(() => regenerateGlobalContext(['opencode'])).not.toThrow();
+        expect(regenerateGlobalContext(['opencode'])).toEqual([{ agent: 'opencode', action: 'skipped' }]);
     });
     it('skips agent when contextStatus throws an unexpected error', () => {
         seedRegistry();
@@ -100,7 +100,38 @@ describe('regenerateGlobalContext', () => {
         const { InjectionOrchestrator } = require('../../../src/core/context/orchestrator');
         const brokenOrch = new InjectionOrchestrator();
         brokenOrch.contextStatus = () => { throw new Error('unexpected orchestrator error'); };
-        expect(regenerateGlobalContext(undefined, brokenOrch)).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(regenerateGlobalContext(['opencode'], brokenOrch)).toEqual([{ agent: 'opencode', action: 'skipped' }]);
         expect(fs_1.default.existsSync(contextPath())).toBe(false); // installContext never called
     });
+    // Regresion: el filtro exigia `type === 'config-instructions'`, o sea que
+    // SOLO se regeneraba OpenCode. Para codex/cursor/copilot
+    // (`managed-agents-md`) `awm update` era un no-op silencioso — ni siquiera
+    // un aviso — y la unica forma de refrescar el contexto era volver a correr
+    // `awm init`. Y como doctor reporta `status: healthy` / exit 0 ante un
+    // contexto 'stale', un AGENTS.md desactualizado era invisible para
+    // cualquier gate de CI que mirara el codigo de salida.
+    it('codex (managed-agents-md con globalPath) ya no se saltea por tipo', () => {
+        seedRegistry();
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        const seen = [];
+        const orch = {
+            contextStatus: (op) => { seen.push(op.agent); return 'absent'; },
+            installContext: () => undefined,
+        };
+        regenerateGlobalContext(['codex'], orch);
+        expect(seen).toEqual(['codex']);
+    });
+    it('cursor y copilot se saltean: no tienen archivo de contexto GLOBAL que regenerar', () => {
+        seedRegistry();
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        const seen = [];
+        const orch = {
+            contextStatus: (op) => { seen.push(op.agent); return 'absent'; },
+            installContext: () => undefined,
+        };
+        // Su `injection.globalPath` es null — su contexto es project-local, y
+        // eso no es trabajo de una regeneracion global.
+        expect(regenerateGlobalContext(['cursor', 'copilot'], orch)).toEqual([]);
+        expect(seen).toEqual([]);
+    });
 });