agentic-workflow-manager 3.13.5 → 3.13.6

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/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([]);
+    });
 });

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

@@ -4,7 +4,7 @@ const checks_1 = require("../../../src/core/diagnostics/checks");
 function healthyMachine() {
     return {
         registryCache: { present: true, gitState: 'clean' },
-        hook: { present: true, degraded: false },
+        hook: { present: true, degraded: false, applicable: true },
         devCore: { present: true, brokenLinks: [] },
         ambient: { wanted: [], installed: [] },
         contextInjection: [],
@@ -16,6 +16,7 @@ function healthyProject() {
         root: '/repo/belanz',
         profile: { present: true, extensions: ['frontend'] },
         activeBundles: { expected: ['frontend-craft'], linked: ['frontend-craft'], broken: [] },
+        orphanLinks: { repairable: [], dead: [] },
         sensors: { present: true },
         constitution: { present: true },
         context: { present: true, file: 'CLAUDE.md' },
@@ -80,12 +81,12 @@ describe('runChecks — machine.cli', () => {
 describe('runChecks — machine.hook / devCore', () => {
     it('hook degraded → warn', () => {
         const m = healthyMachine();
-        m.hook = { present: true, degraded: true };
+        m.hook = { present: true, degraded: true, applicable: true };
         expect(byId({ machine: m, project: null }, 'machine.hook').status).toBe('warn');
     });
     it('hook absent → missing + awm init', () => {
         const m = healthyMachine();
-        m.hook = { present: false };
+        m.hook = { present: false, applicable: true };
         const c = byId({ machine: m, project: null }, 'machine.hook');
         expect(c.status).toBe('missing');
         expect(c.remedy).toEqual({ kind: 'command', value: 'awm init' });
@@ -162,7 +163,7 @@ describe('machineChecks — global skill integrity', () => {
         return {
             machine: {
                 registryCache: { present: true, gitState: 'clean' },
-                hook: { present: true, degraded: false },
+                hook: { present: true, degraded: false, applicable: true },
                 devCore: { present: true, brokenLinks: [] },
                 ambient: { wanted: [], installed: [] },
                 contextInjection: [],
@@ -194,8 +195,15 @@ describe('computeProviderOverall (Task 9)', () => {
             checks: states.map((state, i) => ({ id: CHECK_IDS[i % CHECK_IDS.length], state })),
         };
     }
-    it('healthy when every check is in an ok/pending/warn state', () => {
-        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'shared', 'pending-trust', 'stale'])])).toBe('healthy');
+    it('healthy when every check is in an ok/pending state', () => {
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'shared', 'pending-trust'])])).toBe('healthy');
+    });
+    it('degraded cuando algun check esta stale — un contexto viejo tiene que verse en el exit code', () => {
+        // Antes `stale` quedaba fuera de los estados degradantes, asi que doctor
+        // imprimia ⚠ junto a `status: healthy` y exit 0. Un AGENTS.md
+        // desactualizado (o pisado por otro provider) era invisible para
+        // cualquier gate de CI que mirara el codigo de salida.
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'stale'])])).toBe('degraded');
     });
     it('degrades on a single broken/missing/absent/unsupported/conflict check', () => {
         expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'absent'])])).toBe('degraded');

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

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //    `contextStatus` about 'global' for these providers always resolved to
 //    'absent' regardless of whether the local injection actually succeeded.
 // 3. `skillsGlobalCheck`'s renderer-awareness fix (deferred Task 4.3 finding):
-//    `classifyGlobalSkills` only ever sees symlinks, so a rendered format
+//    `classifySkillLinks` only ever sees symlinks, so a rendered format
 //    (cursor-mdc, copilot-instructions) always scanned as "0 broken" and
 //    reported a false-green 'healthy' regardless of what was actually on
 //    disk. Non-'link' renderers now report presence-only, honestly.
@@ -174,9 +174,9 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
         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: dev process\nalwaysApply: true\n---\n\nBody.');
-        // classifyGlobalSkills only ever sees symlinks (`if (!lst.isSymbolicLink()) continue;`)
+        // classifySkillLinks only ever sees symlinks (`if (!lst.isSymbolicLink()) continue;`)
         // — a real scan over rulesDir would find nothing here either. Stubbed explicitly so the
-        // test proves the FIX (renderer-gating), not an accident of what classifyGlobalSkills does.
+        // test proves the FIX (renderer-gating), not an accident of what classifySkillLinks does.
         const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
         const facts = gatherProviderChecks(['cursor'], scanSkills);

package/dist/tests/core/diagnostics/rendered-artifact-visibility.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: el ESCRITOR estampa la extension del renderer sobre el nombre
+// (`using-awm.mdc`, `using-awm.instructions.md`, `development-process.toml`)
+// pero los LECTORES de diagnostico buscaban el nombre pelado. Consecuencia para
+// Cursor y Copilot: nada figuraba jamas como instalado, asi que
+//   - `awm init` NUNCA era idempotente — reinstalaba el baseline entero en cada
+//     corrida, dejando 2 directorios de backup sin podar por corrida;
+//   - `awm doctor` mostraba `✖ dev-core` / `✖ active bundles` de forma
+//     permanente, con un remedio (`awm init` / `awm sync`) que no podia
+//     satisfacerlo nunca.
+// Y lo mismo para los artefactos `agent` de claude-code — el provider POR
+// DEFECTO — porque su installName es `<n>.md` y el lector mapeaba solo el caso
+// `.toml` de codex.
+//
+// Estos tests recorren la misma funcion que usa el escritor
+// (`renderedFilename`), asi que lector y escritor no pueden volver a discrepar.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const registry_1 = require("../../../src/core/renderers/registry");
+const install_planner_1 = require("../../../src/core/install-planner");
+describe('renderedFilename: una sola fuente de verdad para el nombre en disco', () => {
+    it.each([
+        ['link deja el nombre tal cual', 'using-awm', 'link', 'using-awm'],
+        ['link conserva el .md del installName', 'development-process.md', 'link', 'development-process.md'],
+        ['cursor-mdc', 'using-awm', 'cursor-mdc', 'using-awm.mdc'],
+        ['cursor-mdc recorta el .md antes de estampar', 'using-awm.md', 'cursor-mdc', 'using-awm.mdc'],
+        ['copilot-instructions', 'using-awm', 'copilot-instructions', 'using-awm.instructions.md'],
+        ['codex-agent-toml', 'development-process.md', 'codex-agent-toml', 'development-process.toml'],
+    ])('%s', (_n, installName, renderer, expected) => {
+        expect((0, registry_1.renderedFilename)(installName, renderer)).toBe(expected);
+    });
+    it('no usa path.parse().name — un nombre con puntos internos no se trunca', () => {
+        // `path.parse('v1.2-migration').name` === 'v1', lo que perderia
+        // `2-migration` y podria colisionar con otro skill llamado `v1`.
+        expect((0, registry_1.renderedFilename)('v1.2-migration', 'cursor-mdc')).toBe('v1.2-migration.mdc');
+    });
+});
+describe('el lector de diagnostico ve lo que el escritor dejo en disco', () => {
+    let projectRoot;
+    beforeEach(() => {
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rendered-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    // El invariante que importa: el nombre que el escritor produce y el que el
+    // lector busca salen de la MISMA funcion. Se verifica sobre el destino real
+    // que planifica `physicalTarget`, no sobre una reconstruccion a mano.
+    it.each([
+        ['cursor'], ['copilot'], ['claude-code'], ['codex'], ['opencode'], ['antigravity'],
+    ])('%s: el basename del destino planificado coincide con renderedFilename', (agent) => {
+        const { targetPath, renderer } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, agent, 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe((0, registry_1.renderedFilename)('using-awm', renderer));
+    });
+    it('cursor: el destino termina en .mdc (el lector que buscaba el nombre pelado nunca lo encontraba)', () => {
+        const { targetPath } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, 'cursor', 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe('using-awm.mdc');
+        expect(fs_1.default.existsSync(path_1.default.join(path_1.default.dirname(targetPath), 'using-awm'))).toBe(false);
+    });
+    it('copilot: el destino termina en .instructions.md', () => {
+        const { targetPath } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, 'copilot', 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe('using-awm.instructions.md');
+    });
+});

package/dist/tests/core/init/all-baseline-bundles.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// `awm init` and `awm update` disagreed about what "the baseline" is.
+//
+//   init   (steps.ts)          bundles.find(b => b.scope === 'baseline')     ← the FIRST one
+//   update (reconciliation.ts) bundles.filter(b => b.scope === 'baseline' …) ← all of them
+//
+// A registry shipping two baseline bundles therefore installed one on `awm init` and
+// two on the next `awm update` — and the diagnostic that decides whether the baseline
+// is satisfied used `find` too, so it agreed with init and disagreed with update. The
+// second bundle appeared out of nowhere on an unrelated command, and nothing before
+// that had reported it missing.
+//
+// `filter` is the correct reading: `scope: 'baseline'` is a property a bundle HAS, not
+// a slot only one bundle can occupy.
+const steps_1 = require("../../../src/core/init/steps");
+function bundle(name, scope) {
+    return {
+        name, description: '', version: '1.0.0', scope, visibility: 'public',
+        dependsOn: [], skills: [], workflows: [], agents: [], source: `bundles/${name}`,
+    };
+}
+function deps(bundles) {
+    const installs = [];
+    const d = {
+        cwd: '/repo',
+        agent: 'claude-code',
+        enabledAgents: ['claude-code'],
+        bundles,
+        installMethod: 'symlink',
+        registryRoot: '',
+        contentDir: '',
+        sensorPacksRoot: '',
+        ctx: {
+            machine: { devCore: { present: false, brokenLinks: [] } },
+            project: null,
+        },
+        actions: { installBundle: (o) => { installs.push(o.bundleName); } },
+    };
+    return { d, installs };
+}
+describe('awm init installs every baseline bundle, like awm update reconciles every one', () => {
+    it('installs all of them, not just the first', () => {
+        const { d, installs } = deps([
+            bundle('dev-core', 'baseline'),
+            bundle('team-baseline', 'baseline'),
+            bundle('frontend', 'project'),
+        ]);
+        const result = (0, steps_1.stepDevCore)(d);
+        expect(installs).toEqual(['dev-core', 'team-baseline']);
+        expect(result.action).toBe('applied');
+    });
+    it('installs nothing from a non-baseline scope', () => {
+        const { d, installs } = deps([bundle('dev-core', 'baseline'), bundle('extras', 'ambient')]);
+        (0, steps_1.stepDevCore)(d);
+        expect(installs).toEqual(['dev-core']);
+    });
+    it('still skips entirely when the baseline is already satisfied', () => {
+        const { d, installs } = deps([bundle('dev-core', 'baseline'), bundle('team-baseline', 'baseline')]);
+        d.ctx.machine.devCore.present = true;
+        expect((0, steps_1.stepDevCore)(d).action).toBe('skipped');
+        expect(installs).toEqual([]);
+    });
+});