agentic-workflow-manager 3.13.5 → 3.13.6

package/dist/tests/core/provider-artifacts.test.js

@@ -42,24 +42,76 @@ describe('scanLegacyArtifacts', () => {
             process.env.AWM_HOME = originalAwmHome;
         fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
     });
-    it('never lists Codex TOML agents for legacy removal', () => {
+    /** Registra artefactos como propiedad de AWM, que es lo que ahora habilita
+     *  que `awm remove` los ofrezca. */
+    function own(records) {
+        const file = path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        fs_1.default.writeFileSync(file, JSON.stringify(records.map((r) => ({
+            ...r, scope: 'global', sourcePath: '/tmp/src', owners: ['codex'],
+        }))));
+    }
+    it('lista los artefactos renderizados que AWM instalo, incluidos los .toml de codex', () => {
+        // Este test asertaba lo contrario: que los agents TOML de codex NUNCA
+        // se listaran. Eso codificaba el bug — `scanLegacyArtifacts` se tragaba
+        // `UnsupportedRendererError`, asi que `awm remove` era un no-op
+        // permanente para los skills de cursor/copilot y los agents de codex
+        // ("no hay artefactos instalados", con el directorio lleno).
+        // Un artefacto que AWM instalo tiene que poder desinstalarse.
         const skillPath = path_1.default.join(tmpHome, '.agents/skills/linked-skill');
-        const agentPath = path_1.default.join(tmpHome, '.codex/agents/protected.toml');
+        const agentPath = path_1.default.join(tmpHome, '.codex/agents/rendered.toml');
         fs_1.default.mkdirSync(skillPath, { recursive: true });
         fs_1.default.mkdirSync(path_1.default.dirname(agentPath), { recursive: true });
-        fs_1.default.writeFileSync(agentPath, 'name = "protected"\n');
+        fs_1.default.writeFileSync(agentPath, 'name = "rendered"\n');
+        own([
+            { name: 'linked-skill', type: 'skill', targetPath: skillPath, renderer: 'link' },
+            { name: 'rendered.toml', type: 'agent', targetPath: agentPath, renderer: 'codex-agent-toml' },
+        ]);
         const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['codex'], 'global');
-        const legacyRemove = jest.fn((target) => fs_1.default.rmSync(target, {
-            recursive: true,
-            force: true,
-        }));
-        for (const artifact of listed) {
-            for (const fullPath of artifact.fullPaths)
-                legacyRemove(fullPath);
-        }
-        expect(listed.map((artifact) => artifact.name)).toEqual(['linked-skill']);
-        expect(legacyRemove).not.toHaveBeenCalledWith(agentPath);
-        expect(fs_1.default.existsSync(agentPath)).toBe(true);
+        expect(listed.map((a) => a.name).sort()).toEqual(['linked-skill', 'rendered.toml']);
+    });
+    it('NO lista archivos que AWM no instalo — el directorio no es suyo para ofrecerlo', () => {
+        // Antes listaba el directorio entero, asi que un skill escrito a mano
+        // por el usuario aparecia en el menu de borrado.
+        const mine = path_1.default.join(tmpHome, '.agents/skills/awm-skill');
+        const theirs = path_1.default.join(tmpHome, '.agents/skills/mi-skill-personal');
+        fs_1.default.mkdirSync(mine, { recursive: true });
+        fs_1.default.mkdirSync(theirs, { recursive: true });
+        own([{ name: 'awm-skill', type: 'skill', targetPath: mine, renderer: 'link' }]);
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['codex'], 'global');
+        expect(listed.map((a) => a.name)).toEqual(['awm-skill']);
+        expect(listed.flatMap((a) => a.fullPaths)).not.toContain(theirs);
+    });
+    it('no colapsa dos tipos distintos que comparten nombre (borraria el equivocado)', () => {
+        // Antes la clave era solo el nombre, a traves de todos los tipos: un
+        // workflow `deploy.md` y un agent `deploy.md` colapsaban en UNA entrada,
+        // asi que elegir "deploy.md" borraba ambos.
+        const wf = path_1.default.join(tmpHome, '.gemini/antigravity/global_workflows/deploy.md');
+        const ag = path_1.default.join(tmpHome, '.claude/agents/deploy.md');
+        fs_1.default.mkdirSync(path_1.default.dirname(wf), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.dirname(ag), { recursive: true });
+        fs_1.default.writeFileSync(wf, 'wf');
+        fs_1.default.writeFileSync(ag, 'ag');
+        own([
+            { name: 'deploy.md', type: 'workflow', targetPath: wf, renderer: 'link' },
+            { name: 'deploy.md', type: 'agent', targetPath: ag, renderer: 'link' },
+        ]);
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['antigravity', 'claude-code'], 'global');
+        expect(listed).toHaveLength(2);
+        for (const a of listed)
+            expect(a.fullPaths).toHaveLength(1);
+    });
+    it('scope local se resuelve contra el projectRoot dado, no contra cwd', () => {
+        const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-proj-'));
+        const local = path_1.default.join(projectRoot, '.claude/skills/local-skill');
+        fs_1.default.mkdirSync(local, { recursive: true });
+        own([{ name: 'local-skill', type: 'skill', targetPath: local, renderer: 'link' }]);
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['claude-code'], 'local', projectRoot);
+        expect(listed.map((a) => a.name)).toEqual(['local-skill']);
+        // Y la ruta entregada es ABSOLUTA: antes era relativa, y se la pasaba
+        // tal cual a fs.rmSync.
+        expect(path_1.default.isAbsolute(listed[0].fullPaths[0])).toBe(true);
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
     });
     it('Gap C — an agent with a null global skill dir (copilot) at global scope skips cleanly instead of crashing', () => {
         // Copilot's skill.global is null (no user-level skill discovery mechanism —

package/dist/tests/core/provider-capability-guards.test.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: un provider que estructuralmente NO puede recibir un artefacto en
+// cierto scope (hoy: copilot en global — no tiene descubrimiento de skills a
+// nivel usuario) hacia TIRAR el plan entero, rompiendo el comando para todos
+// los demas agentes de la maquina.
+//
+// Sintoma confirmado contra el binario real:
+//     awm init -a claude-code -y && awm init -a copilot -y && awm update
+//     → Artifact reconciliation failed: skill global scope is not supported by Copilot
+//     exit=1
+// El comando moria ANTES del re-sync de hooks, asi que claude-code dejaba de
+// recibir actualizaciones — y no existe comando para deshabilitar un agente,
+// mientras `awm doctor` seguia diciendo "healthy".
+//
+// La causa era una asimetria de guarda clasica: el `.filter()` interno de
+// `assertCompleteSharedGroup` ya toleraba el caso, pero la linea de arriba
+// —que corre primero— no.
+const path_1 = __importDefault(require("path"));
+const install_planner_1 = require("../../src/core/install-planner");
+const skill = {
+    name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/reg/skills/using-awm',
+};
+describe('planInstall: un provider incapaz no puede romper el plan de los demas', () => {
+    it('scope global con copilot habilitado: planifica para los capaces y saltea copilot', () => {
+        const plan = (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['claude-code', 'copilot'],
+            enabledAgents: ['claude-code', 'copilot'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        });
+        const owners = plan.operations.flatMap((op) => op.owners);
+        expect(owners).toContain('claude-code');
+        expect(owners).not.toContain('copilot');
+    });
+    it('no tira aunque copilot este habilitado pero no seleccionado (el caso de awm update)', () => {
+        expect(() => (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['claude-code'],
+            enabledAgents: ['claude-code', 'copilot'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        })).not.toThrow();
+    });
+    it('peticion EXPLICITA de copilot en global: sigue tirando CON la explicacion', () => {
+        // Aca no hay a quien saltear — el usuario pidio justo esa combinacion, y
+        // lo que necesita es leer por que no se puede, no un exito silencioso.
+        expect(() => (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['copilot'],
+            enabledAgents: ['copilot'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        })).toThrow(/per-project|not supported/i);
+    });
+    it('copilot en scope local SI recibe el artefacto (su unico scope valido)', () => {
+        const plan = (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['copilot'],
+            enabledAgents: ['copilot'],
+            scope: 'local',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        });
+        expect(plan.operations).toHaveLength(1);
+        // `path.join`, no un literal con '/': `physicalTarget` construye la ruta con el
+        // separador de la plataforma, asi que en Windows el destino real es
+        // `.github\instructions` y la asercion POSIX-hardcodeada fallaba sobre un
+        // destino perfectamente correcto.
+        expect(plan.operations[0].targetPath).toContain(path_1.default.join('.github', 'instructions'));
+        expect(plan.operations[0].targetPath).toContain('using-awm.instructions.md');
+    });
+    it('el grupo compartido (opencode + codex) se sigue exigiendo completo', () => {
+        // La guarda no debe aflojar R14: ambos resuelven a ~/.agents/skills, asi
+        // que seleccionar solo uno seguiria siendo un cambio divergente.
+        expect(() => (0, install_planner_1.planInstall)({
+            artifacts: [skill],
+            selectedAgents: ['codex'],
+            enabledAgents: ['codex', 'opencode'],
+            scope: 'global',
+            projectRoot: '/tmp/proj',
+            method: 'symlink',
+        })).toThrow(/shared skill target/i);
+    });
+});

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

@@ -138,10 +138,18 @@ describe('planReconciliation (real, unmocked)', () => {
         // points nowhere — resolveBundleClosure just drops the missing dep.
         expect(names).toEqual(['ambient-skill', 'brainstorming', 'dangling-skill']);
     });
-    it('skips a bundle whose closure genuinely fails to resolve, without aborting reconciliation for the rest', () => {
-        // Malformed dependsOn (not an array) makes resolveBundleClosure throw
-        // when it tries to iterate it — a real "unresolvable closure" error,
-        // unlike a plain dangling name reference (see test above).
+    it('un dependsOn malformado ya no rompe nada: el campo invalido se ignora y el bundle instala', () => {
+        // Este test asertaba que un `dependsOn` no-array hacia TIRAR a
+        // `resolveBundleClosure` y que reconciliation lo salteaba. Desde que
+        // `discoverBundles` valida forma sobre el contenido del registry (que es
+        // input no confiable), ese campo se normaliza a `[]` en vez de
+        // propagarse hasta un `for...of` sobre un numero. O sea: la entrada ya
+        // no falla, y el bundle instala normalmente ignorando el campo roto.
+        //
+        // Es una mejora, no una regresion — antes UN archivo malformado en
+        // cualquier registry tumbaba `awm list`/`awm add` con un stack trace
+        // crudo. El `catch` de reconciliation sigue en su lugar como defensa en
+        // profundidad, pero esta entrada ya no lo ejercita.
         writeBundle(contentRoot, 'broken', 'baseline', ['broken-skill'], 5);
         addToCatalog(contentRoot, 'broken', 'baseline');
         const { planReconciliation } = require('../../src/core/reconciliation');
@@ -149,17 +157,9 @@ describe('planReconciliation (real, unmocked)', () => {
         expect(() => {
             plan = planReconciliation({ targets: ['claude-code'], roots: [contentRoot] });
         }).not.toThrow();
-        // The healthy bundles (baseline 'dev' + ambient 'ambient-x') still
-        // reconcile correctly.
         const names = plan.operations.map((op) => op.name).sort();
-        expect(names).toEqual(['ambient-skill', 'brainstorming']);
-        // The broken bundle is cleanly absent — no partial/broken entry for
-        // 'broken-skill' or any operation touching it.
-        expect(names).not.toContain('broken-skill');
-        expect(plan.operations.some((op) => op.sourcePath?.includes('broken'))).toBe(false);
-        // Applying the plan end-to-end still works (no dangling reference to
-        // the broken bundle leaked into the plan).
-        const { applyInstallPlan } = require('../../src/core/install-transaction');
-        expect(() => applyInstallPlan(plan)).not.toThrow();
+        // Los bundles sanos siguen reconciliando, y el que tenia el campo roto
+        // tambien — sin su dependencia invalida.
+        expect(names).toEqual(['ambient-skill', 'brainstorming', 'broken-skill']);
     });
 });

package/dist/tests/core/registry-manifest.test.js

@@ -69,7 +69,7 @@ describe('registry manifest (awm-registry.json)', () => {
     });
     it('registryNameForPath maps configured registries and returns null for unknown paths', () => {
         const m = load();
-        const regPath = path_1.default.join(m.REGISTRIES_DIR, 'team-acme', 'skills', 'x');
+        const regPath = path_1.default.join(m.registriesDir(), 'team-acme', 'skills', 'x');
         expect(m.registryNameForPath(regPath)).toBe('team-acme');
         expect(m.registryNameForPath('/somewhere/else')).toBeNull();
     });

package/dist/tests/core/semver-fails-closed.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: `compareSemver` devolvia NaN ante una entrada malformada, y como
+// `NaN > 0` y `NaN < 0` son AMBOS false, el gate de version fallaba ABIERTO:
+// `verifyMinCliVersions` dejaba pasar en silencio un CLI por debajo del minimo.
+// Para un gate, la direccion correcta de fallo es la contraria.
+const versioning_1 = require("../../src/core/versioning");
+describe('compareSemver', () => {
+    it.each([
+        ['1.2.3', '1.2.3', 0],
+        ['1.2.4', '1.2.3', 1],
+        ['1.2.3', '1.3.0', -1],
+        ['2.0.0', '1.99.99', 1],
+        ['v1.2.3', '1.2.3', 0],
+    ])('compara %s con %s', (a, b, sign) => {
+        expect(Math.sign((0, versioning_1.compareSemver)(a, b))).toBe(sign);
+    });
+    it.each([
+        ['incompleta', '1.2'],
+        ['no numerica', 'x.y.z'],
+        ['vacia', ''],
+        ['basura', 'latest'],
+    ])('lanza ante una version %s en vez de devolver NaN', (_n, bad) => {
+        expect(() => (0, versioning_1.compareSemver)(bad, '1.0.0')).toThrow(/not a semver/i);
+        expect(() => (0, versioning_1.compareSemver)('1.0.0', bad)).toThrow(/not a semver/i);
+    });
+    it('nunca devuelve NaN — el valor que hacia fallar el gate abierto', () => {
+        expect(Number.isNaN((0, versioning_1.compareSemver)('1.0.0', '2.0.0'))).toBe(false);
+    });
+});

package/dist/tests/core/skill-integrity.test.js

@@ -16,7 +16,7 @@ describe('skill-integrity multi-root', () => {
     afterEach(() => {
         fs_1.default.rmSync(tmp, { recursive: true, force: true });
     });
-    it('repairGlobalSkills re-links a dangling symlink to the FIRST root that has the skill', () => {
+    it('repairSkillLinks re-links a dangling symlink to the FIRST root that has the skill', () => {
         const skillsDir = path_1.default.join(tmp, 'installed');
         const rootA = path_1.default.join(tmp, 'base');
         const rootB = path_1.default.join(tmp, 'personal');
@@ -25,16 +25,16 @@ describe('skill-integrity multi-root', () => {
         fs_1.default.writeFileSync(path_1.default.join(rootB, 'skills', 'mine', 'SKILL.md'), '---\nname: mine\n---\n');
         // dangling symlink: points to a deleted target
         fs_1.default.symlinkSync(path_1.default.join(tmp, 'gone', 'mine'), path_1.default.join(skillsDir, 'mine'), 'dir');
-        const { repairGlobalSkills: repair } = require('../../src/core/skill-integrity');
+        const { repairSkillLinks: repair } = require('../../src/core/skill-integrity');
         const r = repair(skillsDir, [rootA, rootB]);
         expect(r.relinked).toEqual(['mine']);
         expect(fs_1.default.realpathSync(path_1.default.join(skillsDir, 'mine'))).toBe(fs_1.default.realpathSync(path_1.default.join(rootB, 'skills', 'mine')));
     });
-    it('classifyGlobalSkills marks dead when NO root has the skill', () => {
+    it('classifySkillLinks marks dead when NO root has the skill', () => {
         const skillsDir = path_1.default.join(tmp, 'installed');
         fs_1.default.mkdirSync(skillsDir, { recursive: true });
         fs_1.default.symlinkSync(path_1.default.join(tmp, 'gone', 'nope'), path_1.default.join(skillsDir, 'nope'), 'dir');
-        const { classifyGlobalSkills: classify } = require('../../src/core/skill-integrity');
+        const { classifySkillLinks: classify } = require('../../src/core/skill-integrity');
         const c = classify(skillsDir, [path_1.default.join(tmp, 'base')]);
         expect(c.dead).toEqual(['nope']);
     });
@@ -53,7 +53,7 @@ function makeRegistrySkill(registryContentDir, name) {
     fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), `# ${name}\n`);
     return dir;
 }
-describe('classifyGlobalSkills', () => {
+describe('classifySkillLinks', () => {
     it('classifies valid / repairable / dead', () => {
         const { skillsDir, registryContentDir } = setup();
         // valid: symlink a una skill que existe en el registry
@@ -64,13 +64,13 @@ describe('classifyGlobalSkills', () => {
         fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/beta'), path_1.default.join(skillsDir, 'beta'), 'dir');
         // dead: symlink colgante y la skill NO existe en el registry
         fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/gamma'), path_1.default.join(skillsDir, 'gamma'), 'dir');
-        const result = (0, skill_integrity_1.classifyGlobalSkills)(skillsDir, [registryContentDir]);
+        const result = (0, skill_integrity_1.classifySkillLinks)(skillsDir, [registryContentDir]);
         expect(result.valid).toEqual(['alpha']);
         expect(result.repairable).toEqual(['beta']);
         expect(result.dead).toEqual(['gamma']);
     });
     it('returns empty arrays when the skills dir does not exist', () => {
-        const result = (0, skill_integrity_1.classifyGlobalSkills)('/nonexistent/dir', ['/also/nonexistent']);
+        const result = (0, skill_integrity_1.classifySkillLinks)('/nonexistent/dir', ['/also/nonexistent']);
         expect(result).toEqual({ valid: [], repairable: [], dead: [] });
     });
 });
@@ -117,7 +117,7 @@ describe('reconcileAllSkillLinks (#4 — awm update, all providers)', () => {
         }
     });
 });
-describe('repairGlobalSkills', () => {
+describe('repairSkillLinks', () => {
     it('re-links repairable to registry content dir and prunes dead; valid untouched; idempotent', () => {
         const { skillsDir, registryContentDir } = setup();
         const okTarget = makeRegistrySkill(registryContentDir, 'alpha');
@@ -125,7 +125,7 @@ describe('repairGlobalSkills', () => {
         makeRegistrySkill(registryContentDir, 'beta');
         fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/beta'), path_1.default.join(skillsDir, 'beta'), 'dir');
         fs_1.default.symlinkSync(path_1.default.join('/nonexistent/old-root/gamma'), path_1.default.join(skillsDir, 'gamma'), 'dir');
-        const r1 = (0, skill_integrity_1.repairGlobalSkills)(skillsDir, [registryContentDir]);
+        const r1 = (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registryContentDir]);
         expect(r1.relinked).toEqual(['beta']);
         expect(r1.pruned).toEqual(['gamma']);
         // beta ahora apunta al registry content dir y resuelve
@@ -137,7 +137,7 @@ describe('repairGlobalSkills', () => {
         // alpha intacto
         expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 'alpha'))).toBe(true);
         // idempotente: segunda corrida no cambia nada
-        const r2 = (0, skill_integrity_1.repairGlobalSkills)(skillsDir, [registryContentDir]);
+        const r2 = (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registryContentDir]);
         expect(r2.relinked).toEqual([]);
         expect(r2.pruned).toEqual([]);
     });

package/dist/tests/core/skill-repair-safety.test.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: `repairSkillLinks` hacia `rmSync` del link colgante y RECIEN
+// DESPUES intentaba recrearlo con `symlinkSync(..., 'dir')`. En Windows un
+// symlink de directorio exige SeCreateSymbolicLinkPrivilege, denegado por
+// defecto en cuentas sin privilegios — asi que el link se borraba y la
+// recreacion tiraba EPERM: el usuario quedaba PEOR que antes, y con la entrada
+// ya ausente el siguiente `awm init` ni siquiera podia verla como reparable.
+//
+// `executor.ts` documenta en extenso que en win32 hay que usar `'junction'`
+// (que cualquier cuenta puede crear, y que libuv reporta igual que un symlink);
+// este sitio nunca recibio ese fix.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const skill_integrity_1 = require("../../src/core/skill-integrity");
+describe('repairSkillLinks: un fallo nunca deja al usuario peor que antes', () => {
+    let skillsDir;
+    let registry;
+    beforeEach(() => {
+        const base = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-repair-'));
+        skillsDir = path_1.default.join(base, 'skills-installed');
+        registry = path_1.default.join(base, 'registry');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(registry, 'skills', 'alpha'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: d\n---\nb');
+    });
+    /** Un symlink colgante: apunta a algo que no existe, pero el registry SI
+     *  tiene la skill — o sea, reparable. */
+    function danglingLink(name) {
+        fs_1.default.symlinkSync(path_1.default.join(skillsDir, '__no_existe__'), path_1.default.join(skillsDir, name), 'dir');
+    }
+    it('repara un link colgante apuntandolo al registry', () => {
+        danglingLink('alpha');
+        const result = (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registry]);
+        expect(result.relinked).toContain('alpha');
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 'alpha'))).toBe(true);
+        expect(fs_1.default.realpathSync(path_1.default.join(skillsDir, 'alpha')))
+            .toBe(fs_1.default.realpathSync(path_1.default.join(registry, 'skills', 'alpha')));
+    });
+    it('si la creacion del link falla, el estado original NO se destruye', () => {
+        danglingLink('alpha');
+        const before = fs_1.default.readlinkSync(path_1.default.join(skillsDir, 'alpha'));
+        // Simula la denegacion de privilegio de Windows.
+        const spy = jest.spyOn(fs_1.default, 'symlinkSync').mockImplementation(() => {
+            const err = new Error('operation not permitted');
+            err.code = 'EPERM';
+            throw err;
+        });
+        try {
+            const result = (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registry]);
+            expect(result.failed).toContain('alpha');
+            expect(result.relinked).not.toContain('alpha');
+            // Lo que importa: la entrada sigue existiendo, con su target
+            // original. Antes quedaba borrada — invisible incluso para el
+            // proximo intento de reparacion.
+            expect(fs_1.default.lstatSync(path_1.default.join(skillsDir, 'alpha')).isSymbolicLink()).toBe(true);
+            expect(fs_1.default.readlinkSync(path_1.default.join(skillsDir, 'alpha'))).toBe(before);
+        }
+        finally {
+            spy.mockRestore();
+        }
+    });
+    it('no deja archivos de staging tirados tras una reparacion exitosa', () => {
+        danglingLink('alpha');
+        (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registry]);
+        expect(fs_1.default.readdirSync(skillsDir).filter((e) => e.includes('.relink'))).toEqual([]);
+    });
+    it('no deja archivos de staging tirados tras un fallo', () => {
+        danglingLink('alpha');
+        const spy = jest.spyOn(fs_1.default, 'renameSync').mockImplementation(() => { throw new Error('boom'); });
+        try {
+            (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registry]);
+        }
+        finally {
+            spy.mockRestore();
+        }
+        // El staging puede sobrevivir a un crash duro, pero se limpia en el
+        // siguiente intento — se verifica que una segunda pasada converge.
+        (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registry]);
+        expect(fs_1.default.readdirSync(skillsDir).filter((e) => e.includes('.relink'))).toEqual([]);
+    });
+    it('poda un link muerto (sin contraparte en el registry)', () => {
+        danglingLink('fantasma');
+        const result = (0, skill_integrity_1.repairSkillLinks)(skillsDir, [registry]);
+        expect(result.pruned).toContain('fantasma');
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 'fantasma'))).toBe(false);
+    });
+});

package/dist/tests/core/sync-profile-atomicity.test.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `awm sync` over a profile with N extensions ran N independent transactions —
+// one `planInstall` + `applyInstallPlan` per extension, in a loop. Each is atomic on
+// its own, none is atomic with the others, so a failure on extension 3 left 1 and 2
+// installed and the tree in a state that matched neither before nor after:
+//
+//     extensions: [a, b, c]
+//     a → tx-1  committed
+//     b → tx-2  committed
+//     c → throws           ← a and b stay installed, sync exits non-zero
+//
+// And the transaction IDs — the only handle `awm backup restore` accepts — were
+// collected into `transactionIds` and then never printed by any caller, so even the
+// committed halves could not be named to undo them by hand.
+//
+// One plan for the whole sync. `planInstall` already dedups by physical target across
+// artifacts, so combining the extensions loses nothing; and `applyInstallPlan` already
+// rolls its own plan back on any failure, so combining is what makes the sync atomic.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const bundle_install_1 = require("../../src/core/bundle-install");
+function bundle(name, skills, contentRoot) {
+    return {
+        name, description: '', version: '1.0.0', scope: 'project', visibility: 'public',
+        dependsOn: [], skills: skills.map(n => ({ name: n })), workflows: [], agents: [],
+        source: `bundles/${name}`, contentRoot,
+    };
+}
+describe('awm sync is one transaction, not one per extension', () => {
+    let projectRoot;
+    let contentDir;
+    let home;
+    let saved;
+    let bundles;
+    beforeEach(() => {
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-atomic-home-'));
+        saved = { HOME: process.env.HOME, AWM_HOME: process.env.AWM_HOME };
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+        fs_1.default.mkdirSync(path_1.default.join(home, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(home, '.awm', 'preferences.json'), JSON.stringify({
+            enabledAgents: ['claude-code'], defaultAgent: 'claude-code',
+            installMethod: 'symlink', defaultScope: 'global',
+        }));
+        contentDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-atomic-content-'));
+        for (const s of ['skill-a', 'skill-b', 'skill-c']) {
+            fs_1.default.mkdirSync(path_1.default.join(contentDir, 'skills', s), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(contentDir, 'skills', s, 'SKILL.md'), `---\nname: ${s}\ndescription: d\n---\n`);
+        }
+        bundles = [
+            bundle('ext-a', ['skill-a'], contentDir),
+            bundle('ext-b', ['skill-b'], contentDir),
+            bundle('ext-c', ['skill-c'], contentDir),
+        ];
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-atomic-proj-'));
+        fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['ext-a', 'ext-b', 'ext-c'] }));
+    });
+    afterEach(() => {
+        if (saved.HOME === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = saved.HOME;
+        if (saved.AWM_HOME === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = saved.AWM_HOME;
+        for (const d of [home, contentDir, projectRoot])
+            fs_1.default.rmSync(d, { recursive: true, force: true });
+    });
+    const run = (applyPlan) => (0, bundle_install_1.syncProfile)({ projectRoot, bundles, agents: ['claude-code'], method: 'symlink', contentDir, applyPlan });
+    it('applies a single plan covering every extension', () => {
+        const plans = [];
+        const result = run((plan) => {
+            plans.push(plan);
+            return { installed: plan.operations.map(o => o.targetPath), skipped: [], transactionId: 'tx-1', modifiedFiles: [] };
+        });
+        expect(plans).toHaveLength(1);
+        const names = plans[0].operations.map(o => path_1.default.basename(o.targetPath)).sort();
+        expect(names).toEqual(['skill-a', 'skill-b', 'skill-c']);
+        expect(result.transactionIds).toEqual(['tx-1']);
+    });
+    it('installs nothing at all when the apply fails — no half-synced tree', () => {
+        // The failure is on the LAST extension on purpose: with one transaction per
+        // extension, ext-a and ext-b were already committed by the time ext-c blew up.
+        const committed = [];
+        expect(() => run((plan) => {
+            const names = plan.operations.map(o => path_1.default.basename(o.targetPath));
+            if (names.includes('skill-c'))
+                throw new Error('verification failed');
+            committed.push(...names);
+            return { installed: names, skipped: [], transactionId: `tx-${committed.length}`, modifiedFiles: [] };
+        })).toThrow(/verification failed/);
+        expect(committed).toEqual([]);
+    });
+    it('skips unknown extensions without splitting the transaction', () => {
+        fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['ext-a', 'ghost', 'ext-c'] }));
+        const plans = [];
+        const result = run((plan) => {
+            plans.push(plan);
+            return { installed: [], skipped: [], transactionId: 'tx-1', modifiedFiles: [] };
+        });
+        expect(plans).toHaveLength(1);
+        expect(plans[0].operations.map(o => path_1.default.basename(o.targetPath)).sort()).toEqual(['skill-a', 'skill-c']);
+        expect(result.skipped.some(s => s.includes('ghost'))).toBe(true);
+    });
+    it('does not apply anything when every extension is unknown', () => {
+        fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['ghost'] }));
+        let applyCalls = 0;
+        const result = run(() => {
+            applyCalls++;
+            return { installed: [], skipped: [], transactionId: 'tx-1', modifiedFiles: [] };
+        });
+        expect(applyCalls).toBe(0);
+        expect(result.transactionIds).toEqual([]);
+    });
+});

package/dist/tests/integration/copilot-init-isolated.test.js

@@ -75,9 +75,9 @@ describe('copilot provider — isolated home E2E (devCore global-scope guard reg
         fs_1.default.writeFileSync(path_1.default.join(root, 'hooks/session-start'), '#!/bin/sh\necho "{}"\n', { mode: 0o755 });
         fs_1.default.writeFileSync(path_1.default.join(root, 'hooks/run-hook.cmd'), '#!/bin/sh\nexec sh "$1"\n', { mode: 0o755 });
         fs_1.default.mkdirSync(path_1.default.join(root, 'skills/using-awm'), { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/using-awm/SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/using-awm/SKILL.md'), '---\nname: using-awm\ndescription: Entry point for AWM skills.\n---\nMUST invoke skills.');
         fs_1.default.mkdirSync(path_1.default.join(root, 'skills/development-process'), { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/development-process/SKILL.md'), '---\nname: development-process\n---\nOrchestrates the dev lifecycle.');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/development-process/SKILL.md'), '---\nname: development-process\ndescription: Orchestrates the development lifecycle.\n---\nOrchestrates the dev lifecycle.');
         fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
             version: 1,
             bundles: [{ name: 'dev-core', source: 'bundles/dev-core', version: '1.0.0', scope: 'baseline', visibility: 'public' }],

package/dist/tests/providers/index.test.js

@@ -56,7 +56,7 @@ describe('Providers Routing', () => {
         expect((0, providers_1.providerFor)('codex')).toEqual({
             label: 'Codex',
             minimumVersion: '0.145.0',
-            versionCommand: { command: 'codex', args: ['--version'] },
+            versionCommand: { command: 'codex', args: ['--version'], versionPattern: /^codex-cli (\d+\.\d+\.\d+)$/ },
             skill: {
                 global: path_1.default.join(tmpHome, '.agents/skills'),
                 local: '.agents/skills',