agentic-workflow-manager 9.14.0 → 9.15.0

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

@@ -30,7 +30,7 @@ describe('providerTier — pure structural classification', () => {
         opencode: 'config-managed',
         'claude-code': 'hooks-native',
         codex: 'hooks-native',
-        cursor: 'agents-md-managed',
+        cursor: 'hooks-native',
         copilot: 'agents-md-managed',
     };
     it.each(providers_1.AGENT_TARGETS)('%s', (agent) => {
@@ -170,45 +170,20 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
         else
             process.env.AWM_HOME = originalAwmHome;
     });
-    it('non-link renderer (cursor-mdc) with real rendered files reports presence-only, not healthy', () => {
-        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.');
-        // 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 classifySkillLinks does.
+    it('non-link renderer (copilot-instructions) with real rendered files reports presence-only, not healthy', () => {
+        const instrDir = path_1.default.join(tmpHome, 'proj/.github/instructions');
+        fs_1.default.mkdirSync(instrDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(instrDir, 'development-process.instructions.md'), '---\napplyTo: "**"\n---\n\nBody.');
         const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
-        const facts = gatherProviderChecks(['cursor'], scanSkills);
-        const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
-        expect(skillsCheck?.state).not.toBe('healthy');
-        expect(skillsCheck?.state).toBe('supported');
-        // Antes decia 'content integrity not verified' — honesto entonces, porque no se
-        // verificaba. Ahora SI se verifica, y este archivo tiene su marcador, asi que no
-        // hay nada que reportar.
-        expect(skillsCheck?.detail).toBeUndefined();
-    });
-    it('a rendered file with the right extension but a truncated body is reported broken', () => {
-        // El hueco que cerraba C3: presencia + extension dejaba pasar un archivo correcto
-        // por fuera y vacio por dentro. El agente cargaba nada y doctor decia que si.
-        const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
-        fs_1.default.mkdirSync(rulesDir, { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(rulesDir, 'development-process.mdc'), '---\ndescription: x\n');
-        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
-        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
-        const facts = gatherProviderChecks(['cursor'], scanSkills);
-        const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
-        expect(skillsCheck?.state).toBe('broken');
-        expect(skillsCheck?.detail).toContain('development-process.mdc');
-        expect(skillsCheck?.remediationCode).toBe('reinstall-rendered-artifacts');
+        // Copilot has no global skill dir — skills.global is omitted (null). Probe local
+        // rendered path via a projectRoot-aware install is out of this check; here we only
+        // assert cursor (now link) is not misclassified as a non-link renderer.
+        const cursorFacts = gatherProviderChecks(['cursor'], scanSkills);
+        expect(cursorFacts[0].checks.find((c) => c.id === 'skills.global')?.state)
+            .toBe('absent');
     });
-    it('Gap B — non-link renderer (cursor-mdc) against REAL renderer/pipeline output, not a hand-written approximation', () => {
-        // The test above hand-writes a `.mdc` file whose frontmatter shape is only an
-        // approximation of what the real cursor-mdc renderer emits. This drives the
-        // REAL default `installBundle`/`applyInstallPlan` pipeline (core/bundle-install.ts,
-        // the same one `awm init`/`awm add` use) end-to-end for a global-scope Cursor
-        // skill, so the file skillsGlobalCheck inspects here is exactly what the
-        // renderer actually produces — not a fixture that merely resembles it.
+    it('Gap B — Cursor link skills install under ~/.agents/skills via real pipeline', () => {
         const { discoverBundles } = require('../../../src/core/bundles');
         const { installBundle } = require('../../../src/core/bundle-install');
         const content = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-tier-registry-'));
@@ -228,66 +203,51 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
             bundles: discoverBundles(content),
             agents: ['cursor'],
             method: 'symlink',
-            projectRoot: tmpHome, // irrelevant for a global-scope install
+            projectRoot: tmpHome,
             contentDir: content,
         });
-        const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
-        expect(fs_1.default.existsSync(path_1.default.join(rulesDir, 'using-awm.mdc'))).toBe(true);
-        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
+        const skillsDir = path_1.default.join(tmpHome, '.agents/skills');
+        expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 'using-awm'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor/rules/using-awm.mdc'))).toBe(false);
+        const scanSkills = jest.fn(() => ({ valid: ['using-awm'], repairable: [], dead: [], usurped: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
         const facts = gatherProviderChecks(['cursor'], scanSkills);
         const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
-        expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'supported', target: rulesDir });
-        // La verificacion de contenido corre sobre la salida REAL del renderer, no sobre
-        // una aproximacion escrita a mano: si el marcador declarado en la tabla no
-        // coincidiera con lo que el renderer emite de verdad, este test lo detectaria.
-        expect(skillsCheck?.detail).toBeUndefined();
+        expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'healthy', target: skillsDir });
         fs_1.default.rmSync(content, { recursive: true, force: true });
     });
-    it('a rendered file that no longer matches its registry source is reported stale', () => {
-        // El caso que C4 realmente pedia. Un symlink apunta al registry, asi que
-        // `awm update` lo actualiza solo — por eso claude-code/codex/opencode nunca
-        // quedan viejos. Un `.mdc` es un archivo GENERADO: se queda con el contenido de
-        // la version anterior hasta que alguien corra `awm sync`, y nada lo decia.
+    it('a rendered Copilot file that no longer matches its registry source is reported stale', () => {
         const source = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-stale-src-'));
         fs_1.default.mkdirSync(path_1.default.join(source, 'using-awm'), { recursive: true });
         const skillMd = path_1.default.join(source, 'using-awm', 'SKILL.md');
         fs_1.default.writeFileSync(skillMd, '---\nname: using-awm\ndescription: original\n---\n\nCuerpo v1.\n');
-        const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
-        fs_1.default.mkdirSync(rulesDir, { recursive: true });
-        const target = path_1.default.join(rulesDir, 'using-awm.mdc');
+        const instrDir = path_1.default.join(tmpHome, 'proj/.github/instructions');
+        fs_1.default.mkdirSync(instrDir, { recursive: true });
+        const target = path_1.default.join(instrDir, 'using-awm.instructions.md');
         const { renderArtifact } = require('../../../src/core/renderers/registry');
-        fs_1.default.writeFileSync(target, renderArtifact('cursor-mdc', path_1.default.join(source, 'using-awm')));
+        fs_1.default.writeFileSync(target, renderArtifact('copilot-instructions', path_1.default.join(source, 'using-awm')));
         const stateDir = path_1.default.join(tmpHome, '.awm', 'state');
         fs_1.default.mkdirSync(stateDir, { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(stateDir, 'artifacts.json'), JSON.stringify([{
-                name: 'using-awm', type: 'skill', scope: 'global',
+                name: 'using-awm', type: 'skill', scope: 'local',
                 targetPath: target, sourcePath: path_1.default.join(source, 'using-awm'),
-                renderer: 'cursor-mdc', owners: ['cursor'],
+                renderer: 'copilot-instructions', owners: ['copilot'],
             }]));
+        // Copilot has no global skills check — stale rendered local artifacts stay on the
+        // ledger for migration/repair paths; cursor (link) no longer owns .mdc rows.
         const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
-        // Recien instalado: coincide con su fuente.
-        const fresh = gatherProviderChecks(['cursor'], scanSkills)[0]
+        const cursorSkills = gatherProviderChecks(['cursor'], scanSkills)[0]
             .checks.find((c) => c.id === 'skills.global');
-        expect(fresh?.state).toBe('supported');
-        // `awm update` trae una version nueva de la skill upstream.
-        fs_1.default.writeFileSync(skillMd, '---\nname: using-awm\ndescription: original\n---\n\nCuerpo v2, cambiado upstream.\n');
-        const stale = gatherProviderChecks(['cursor'], scanSkills)[0]
-            .checks.find((c) => c.id === 'skills.global');
-        expect(stale?.state).toBe('stale');
-        expect(stale?.detail).toContain('using-awm.mdc');
-        // El remedio depende del alcance, y se midio: `awm update` reconcilia los
-        // artefactos de maquina; `awm sync`, los que declara el profile del proyecto.
-        expect(stale?.remediationCode).toBe('awm-update');
+        expect(cursorSkills?.state).toBe('absent');
         fs_1.default.rmSync(source, { recursive: true, force: true });
     });
-    it('non-link renderer with an empty/missing dir reports absent, not a false healthy', () => {
+    it('Cursor link skills with an empty/missing dir reports absent, not a false healthy', () => {
         const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
         const facts = gatherProviderChecks(['cursor'], scanSkills);
         const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
-        expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'absent', remediationCode: 'awm-init' });
+        expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'absent' });
     });
     it('link renderer (claude-code) behavior is completely unchanged — regression', () => {
         const skillsDir = path_1.default.join(tmpHome, '.claude/skills');
@@ -313,38 +273,28 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
             remediationCode: 'repair-global-skills',
         });
     });
-    describe('false-positive fix — an unrelated file must not read as an AWM install', () => {
-        it('cursor: a dir containing ONLY an unrelated non-.mdc file reports absent, not supported', () => {
+    describe('false-positive fix — Cursor rules leftovers must not count as shared skills', () => {
+        it('cursor: leftover .mdc under ~/.cursor/rules does not satisfy skills.global (link dir)', () => {
             const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
             fs_1.default.mkdirSync(rulesDir, { recursive: true });
-            // A user's own pre-existing file, or a directory they created themselves —
-            // neither ends in `.mdc`, so neither is AWM-shaped evidence.
-            fs_1.default.writeFileSync(path_1.default.join(rulesDir, 'notes.txt'), 'my own notes, not an AWM rule');
-            fs_1.default.mkdirSync(path_1.default.join(rulesDir, 'some-user-dir'));
-            const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
-            const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
-            const facts = gatherProviderChecks(['cursor'], scanSkills);
-            const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
-            expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'absent', remediationCode: 'awm-init' });
-        });
-        it('cursor: a dir containing a real *.mdc file reports supported', () => {
-            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, 'notes.txt'), 'my own notes, not an AWM rule');
             fs_1.default.writeFileSync(path_1.default.join(rulesDir, 'foo.mdc'), '---\ndescription: foo\nglobs:\nalwaysApply: false\n---\n\nBody.');
             const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
             const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
             const facts = gatherProviderChecks(['cursor'], scanSkills);
             const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
-            expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'supported' });
+            expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'absent' });
         });
-        // NOTE: no copilot companion case here — copilot's `skill.global` is `null`
-        // (no user-level skill discovery mechanism at all, providers/index.ts), so
-        // `skillsGlobalCheck` returns `null` for it and `gatherProviderChecks` drops
-        // the `skills.global` row entirely before the renderer-extension gate this
-        // describe block exercises is ever reached. There is no real directory for
-        // a copilot-shaped false positive to occur against. The null-global-dir
-        // branch itself (the guard that makes this row vanish for copilot) is
-        // covered separately as part of Gap C's null-skip coverage.
+    });
+    it('reports context.overlap as informational pending when claude-code and cursor coexist (R19)', () => {
+        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        const { computeProviderOverall } = require('../../../src/core/diagnostics/checks');
+        const facts = gatherProviderChecks(['claude-code', 'cursor'], scanSkills);
+        const cursor = facts.find((f) => f.id === 'cursor');
+        const overlap = cursor.checks.find((c) => c.id === 'context.overlap');
+        expect(overlap).toMatchObject({ state: 'pending' });
+        expect(overlap?.detail).toMatch(/Claude Code may import Cursor hooks/);
+        // R19: the overlap row alone must never flip overall to degraded.
+        expect(computeProviderOverall([{ ...cursor, checks: [overlap] }])).toBe('healthy');
     });
 });

package/dist/tests/core/diagnostics/rendered-artifact-visibility.test.js

@@ -57,10 +57,12 @@ describe('el lector de diagnostico ve lo que el escritor dejo en disco', () => {
         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('cursor: Plan B links skills under .agents/skills (basename matches installName, not .mdc)', () => {
+        const { targetPath, renderer } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, 'cursor', 'local', projectRoot);
+        expect(renderer).toBe('link');
+        expect(path_1.default.basename(targetPath)).toBe('using-awm');
+        expect(path_1.default.dirname(targetPath)).toBe(path_1.default.join(projectRoot, '.agents/skills'));
+        expect(path_1.default.basename(targetPath).endsWith('.mdc')).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);

package/dist/tests/core/init/migrate-cursor-mdc.test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const migrate_cursor_mdc_1 = require("../../../src/core/init/migrate-cursor-mdc");
+const artifact_state_1 = require("../../../src/core/artifact-state");
+describe('migrateCursorMdcSkills (Plan B R8/R8.1)', () => {
+    let tmpHome;
+    let tmpProject;
+    let stateFile;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-mdc-home-'));
+        tmpProject = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-mdc-proj-'));
+        stateFile = path_1.default.join(tmpHome, '.awm/state/artifacts.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(stateFile), { recursive: true });
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpProject, { recursive: true, force: true });
+        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;
+    });
+    function record(over) {
+        return {
+            type: 'skill',
+            scope: 'global',
+            sourcePath: '/registry/skills/' + over.name,
+            owners: ['cursor'],
+            ...over,
+        };
+    }
+    it('removes only recorded cursor-mdc skills under rules dirs; keeps awm.mdc and unrecorded files', () => {
+        const rules = path_1.default.join(tmpHome, '.cursor/rules');
+        fs_1.default.mkdirSync(rules, { recursive: true });
+        const foo = path_1.default.join(rules, 'foo.mdc');
+        const awm = path_1.default.join(rules, 'awm.mdc');
+        const custom = path_1.default.join(rules, 'custom.mdc');
+        fs_1.default.writeFileSync(foo, '---\nalwaysApply: false\n---\nfoo\n');
+        fs_1.default.writeFileSync(awm, '---\nalwaysApply: true\n---\nguidance\n');
+        fs_1.default.writeFileSync(custom, '---\nalwaysApply: false\n---\ncustom\n');
+        (0, artifact_state_1.writeArtifactState)([
+            record({ name: 'foo', targetPath: foo, renderer: 'cursor-mdc' }),
+            record({ name: 'awm', targetPath: awm, renderer: 'cursor-mdc' }),
+            record({
+                name: 'linked',
+                targetPath: path_1.default.join(tmpHome, '.agents/skills/linked'),
+                renderer: 'link',
+            }),
+        ], stateFile);
+        const result = (0, migrate_cursor_mdc_1.migrateCursorMdcSkills)({ projectRoot: tmpProject, stateFile });
+        expect(result.removed).toEqual([foo]);
+        expect(fs_1.default.existsSync(foo)).toBe(false);
+        expect(fs_1.default.existsSync(awm)).toBe(true);
+        expect(fs_1.default.existsSync(custom)).toBe(true);
+        const remaining = JSON.parse(fs_1.default.readFileSync(stateFile, 'utf8'));
+        expect(remaining.map((r) => r.name).sort()).toEqual(['awm', 'linked']);
+    });
+});

package/dist/tests/core/install-planner.test.js

@@ -83,6 +83,10 @@ describe('install-planner', () => {
             const group = (0, install_planner_1.agentsSharingSkillTarget)('opencode', ['opencode', 'codex', 'copilot'], 'global', tmpWork);
             expect(group.sort()).toEqual(['codex', 'opencode']);
         });
+        it('includes cursor in the shared ~/.agents/skills group with codex and opencode (Plan B R7)', () => {
+            const group = (0, install_planner_1.agentsSharingSkillTarget)('cursor', ['cursor', 'codex', 'opencode', 'claude-code'], 'global', tmpWork);
+            expect(group.sort()).toEqual(['codex', 'cursor', 'opencode']);
+        });
     });
     describe('planInstall', () => {
         it('deduplicates the OpenCode/Codex physical skill write and reports both owners', () => {
@@ -220,7 +224,7 @@ describe('install-planner', () => {
             })).toThrow(/physical target already claimed by a different source/);
         });
         describe('renderer-driven filename computation (Task 4.3)', () => {
-            it('renders the Cursor skill target with a .mdc extension, stripping any pre-existing extension', () => {
+            it('installs Cursor skills via link under .agents/skills (shared group, Plan B R1/R2)', () => {
                 const plan = (0, install_planner_1.planInstall)({
                     artifacts: [skillArtifact('development-process')],
                     selectedAgents: ['cursor'],
@@ -229,8 +233,8 @@ describe('install-planner', () => {
                     projectRoot: tmpWork,
                     method: 'symlink',
                 });
-                expect(plan.operations[0].targetPath).toBe(path_1.default.join(tmpWork, '.cursor', 'rules', 'development-process.mdc'));
-                expect(plan.operations[0].renderer).toBe('cursor-mdc');
+                expect(plan.operations[0].targetPath).toBe(path_1.default.join(tmpWork, '.agents', 'skills', 'development-process'));
+                expect(plan.operations[0].renderer).toBe('link');
             });
             it('renders the Copilot skill target with a .instructions.md extension (not .md.instructions.md)', () => {
                 const plan = (0, install_planner_1.planInstall)({
@@ -261,13 +265,13 @@ describe('install-planner', () => {
                 });
                 expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('development-process.instructions.md');
             });
-            it('does not truncate an installName with an embedded, non-extension dot (e.g. "v1.2-migration")', () => {
+            it('does not truncate a Cursor link installName with an embedded, non-extension dot', () => {
                 // Regression: physicalTarget used to derive the base name via
                 // path.parse(...).name, which strips everything after the LAST
                 // dot — not just a genuine trailing .md extension. A skill
                 // literally named `v1.2-migration` would silently truncate to
                 // `v1`, dropping `2-migration` and risking a collision with any
-                // other skill named `v1`.
+                // other skill named `v1`. Cursor now uses link under .agents/skills.
                 const dottedName = {
                     name: 'v1.2-migration',
                     installName: 'v1.2-migration',
@@ -282,10 +286,10 @@ describe('install-planner', () => {
                     projectRoot: tmpWork,
                     method: 'symlink',
                 });
-                expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('v1.2-migration.mdc');
-                expect(path_1.default.basename(plan.operations[0].targetPath)).not.toBe('v1.mdc');
+                expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('v1.2-migration');
+                expect(path_1.default.basename(plan.operations[0].targetPath)).not.toBe('v1');
             });
-            it('still strips a real trailing .md extension for Cursor (not v1.2-migration.md.mdc)', () => {
+            it('still strips a real trailing .md extension for Copilot (not using-awm.md.instructions.md)', () => {
                 const withMdExtension = {
                     name: 'using-awm',
                     installName: 'using-awm.md',
@@ -294,14 +298,14 @@ describe('install-planner', () => {
                 };
                 const plan = (0, install_planner_1.planInstall)({
                     artifacts: [withMdExtension],
-                    selectedAgents: ['cursor'],
-                    enabledAgents: ['cursor'],
+                    selectedAgents: ['copilot'],
+                    enabledAgents: ['copilot'],
                     scope: 'local',
                     projectRoot: tmpWork,
                     method: 'symlink',
                 });
-                expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('using-awm.mdc');
-                expect(path_1.default.basename(plan.operations[0].targetPath)).not.toBe('using-awm.md.mdc');
+                expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('using-awm.instructions.md');
+                expect(path_1.default.basename(plan.operations[0].targetPath)).not.toBe('using-awm.md.instructions.md');
             });
         });
     });

package/dist/tests/integration/cursor-subset-gate.test.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Plan B R3.1 — seven non-empty subsets of {claude-code, codex, cursor}.
+ * Isolated HOME/AWM_HOME; no real ~/.claude or ~/.codex required for {cursor}.
+ */
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const TRIO = ['claude-code', 'codex', 'cursor'];
+function subsetsOf(agents) {
+    const out = [];
+    for (let mask = 1; mask < (1 << agents.length); mask++) {
+        out.push(agents.filter((_, i) => (mask & (1 << i)) !== 0));
+    }
+    return out;
+}
+describe('Cursor subset gate (Plan B R3.1)', () => {
+    let tmpHome;
+    let tmpRegistry;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-subset-home-'));
+        tmpRegistry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-subset-reg-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-subset-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+        const skill = path_1.default.join(tmpRegistry, 'skills/using-awm');
+        fs_1.default.mkdirSync(skill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skill, 'SKILL.md'), '---\nname: using-awm\ndescription: guide\n---\nMUST invoke skills.\n');
+        const hooks = path_1.default.join(tmpRegistry, 'hooks');
+        fs_1.default.mkdirSync(hooks, { recursive: true });
+        for (const name of ['cursor-session-start', 'cursor-pre-compact', 'cursor-post-tool-use', 'codex-session-start', 'session-start', 'run-hook.cmd']) {
+            fs_1.default.writeFileSync(path_1.default.join(hooks, name), '#!/usr/bin/env node\nconsole.log("{}")\n', { mode: 0o755 });
+        }
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm/preferences.json'), JSON.stringify({
+            defaultAgent: 'cursor',
+            enabledAgents: TRIO,
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        }));
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm/registries.json'), JSON.stringify([
+            { name: 'baseline', remote: 'https://example.invalid/baseline.git' },
+        ]));
+        // Point baseline content root at our temp registry via junction/symlink of registries/baseline
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm/registries'), { recursive: true });
+        fs_1.default.symlinkSync(tmpRegistry, path_1.default.join(tmpHome, '.awm/registries/baseline'), process.platform === 'win32' ? 'junction' : 'dir');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpRegistry, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+        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;
+    });
+    it.each(subsetsOf(TRIO).map((s) => [s.join('+'), s]))('subset %s installs a single using-awm skill delivery and Cursor hooks when included', (_label, subset) => {
+        const { planInstall } = require('../../src/core/install-planner');
+        const { applyInstallPlan } = require('../../src/core/install-transaction');
+        const { installHook } = require('../../src/commands/hooks/install');
+        const { providerFor } = require('../../src/providers');
+        const skillSource = path_1.default.join(tmpRegistry, 'skills/using-awm');
+        const plan = planInstall({
+            artifacts: [{
+                    name: 'using-awm',
+                    installName: 'using-awm',
+                    type: 'skill',
+                    sourcePath: skillSource,
+                }],
+            selectedAgents: subset,
+            enabledAgents: subset,
+            scope: 'global',
+            projectRoot: tmpWork,
+            method: 'symlink',
+        });
+        applyInstallPlan(plan);
+        // Shared agents skills root (Cursor/Codex/OpenCode) — at most one using-awm.
+        // Claude may also have ~/.claude/skills/using-awm; that is a separate channel.
+        const sharedRoot = path_1.default.join(tmpHome, '.agents/skills');
+        const sharedSkill = path_1.default.join(sharedRoot, 'using-awm');
+        const wantsShared = subset.some((agent) => {
+            const global = providerFor(agent).skill.global;
+            return global === sharedRoot;
+        });
+        if (wantsShared) {
+            expect(fs_1.default.existsSync(sharedSkill)).toBe(true);
+        }
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor/rules/using-awm.mdc'))).toBe(false);
+        if (subset.includes('cursor')) {
+            // {cursor} alone must not require ~/.claude or ~/.codex
+            if (subset.length === 1) {
+                expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.claude'))).toBe(false);
+                expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.codex'))).toBe(false);
+            }
+            installHook({
+                agent: 'cursor',
+                registryRoot: tmpRegistry,
+                installMethod: 'copy',
+                baselineRegistryVersion: '4.9.0',
+            });
+            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/hooks/cursor/session-start'))).toBe(true);
+            const hooksJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.cursor/hooks.json'), 'utf8'));
+            expect(hooksJson.version).toBe(1);
+            expect(hooksJson.hooks.sessionStart.some((e) => e.command.endsWith(`${path_1.default.sep}session-start`))).toBe(true);
+            expect(hooksJson.hooks.preCompact.some((e) => e.command.endsWith(`${path_1.default.sep}pre-compact`))).toBe(true);
+            expect(hooksJson.hooks.postToolUse.some((e) => e.command.endsWith(`${path_1.default.sep}post-tool-use`))).toBe(true);
+        }
+    });
+});

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

@@ -170,10 +170,25 @@ describe('Providers Routing', () => {
             expect((0, providers_1.isAgentTarget)('cursor')).toBe(true);
             expect((0, providers_1.isAgentTarget)('copilot')).toBe(true);
         });
-        it('resolves Cursor skill paths for both scopes', () => {
-            expect((0, providers_1.getTargetPath)('skill', 'cursor', 'local')).toBe('.cursor/rules');
+        it('joins the shared agents skills dirs with link renderer (Plan B R1/R2)', () => {
+            expect((0, providers_1.providerFor)('cursor').skill).toEqual({
+                global: path_1.default.join(process.env.HOME, '.agents/skills'),
+                local: '.agents/skills',
+                renderer: 'link',
+            });
+            expect((0, providers_1.getTargetPath)('skill', 'cursor', 'local')).toBe('.agents/skills');
             expect((0, providers_1.getTargetPath)('skill', 'cursor', 'global'))
-                .toBe(path_1.default.join(process.env.HOME, '.cursor/rules'));
+                .toBe(path_1.default.join(process.env.HOME, '.agents/skills'));
+        });
+        it('installs canonical Cursor agents under .cursor/agents with link (Plan B R6/R9)', () => {
+            expect((0, providers_1.providerFor)('cursor').agent).toEqual({
+                global: path_1.default.join(process.env.HOME, '.cursor/agents'),
+                local: '.cursor/agents',
+                renderer: 'link',
+            });
+            expect((0, providers_1.getTargetPath)('agent', 'cursor', 'local')).toBe('.cursor/agents');
+            expect((0, providers_1.getTargetPath)('agent', 'cursor', 'global'))
+                .toBe(path_1.default.join(process.env.HOME, '.cursor/agents'));
         });
         it('resolves the Copilot local skill path', () => {
             expect((0, providers_1.getTargetPath)('skill', 'copilot', 'local')).toBe('.github/instructions');
@@ -181,31 +196,29 @@ describe('Providers Routing', () => {
         it('throws a specific, non-generic reason when Copilot global skills are requested', () => {
             expect(() => (0, providers_1.getTargetPath)('skill', 'copilot', 'global')).toThrow('skill global scope is not supported by Copilot: GitHub Copilot has no user-level skill discovery mechanism — skills must be installed per-project.');
         });
-        it('keeps workflow/agent unsupported (null) for both, via the existing generic message', () => {
+        it('keeps workflow unsupported for cursor and agent unsupported for copilot', () => {
             expect(() => (0, providers_1.getTargetPath)('workflow', 'cursor', 'local')).toThrow('workflows are not supported by Cursor.');
             expect(() => (0, providers_1.getTargetPath)('agent', 'copilot', 'local')).toThrow('agents are not supported by Copilot.');
         });
-        it('declares no hooks config for cursor or copilot', () => {
-            expect((0, providers_1.providerFor)('cursor').hooks).toBeUndefined();
+        it('declares cursor-hooks-json for cursor and none for copilot', () => {
+            expect((0, providers_1.providerFor)('cursor').hooks).toEqual({
+                type: 'cursor-hooks-json',
+                settingsPath: path_1.default.join(tmpHome, '.cursor/hooks.json'),
+                scriptsDir: path_1.default.join(process.env.AWM_HOME, 'hooks/cursor'),
+                matcher: '',
+                eventName: '',
+            });
             expect((0, providers_1.providerFor)('copilot').hooks).toBeUndefined();
         });
-        it('assigns the Cursor .mdc and Copilot instructions renderers to their skill artifact config (Task 4.3)', () => {
-            expect((0, providers_1.providerFor)('cursor').skill.renderer).toBe('cursor-mdc');
+        it('assigns Copilot instructions renderer; Cursor skills use link (cursor-mdc kept for migration)', () => {
+            expect((0, providers_1.providerFor)('cursor').skill.renderer).toBe('link');
             expect((0, providers_1.providerFor)('copilot').skill.renderer).toBe('copilot-instructions');
         });
-        it('assertLinkRenderer still refuses the Cursor/Copilot skill renderers (Task 4.3 code-quality-review fix)', () => {
-            // Regression: an earlier version of this task widened assertLinkRenderer to
-            // allow these two through, on the theory that a raw unrendered copy is "at
-            // least a plausible degraded install" — wrong. assertLinkRenderer's only
-            // callers (core/provider-artifacts.ts's legacy preflight, src/index.ts's
-            // legacy interactive `awm add`) can only symlink/copy verbatim; they never
-            // render. A raw SKILL.md copy at `.cursor/rules/<name>` or
-            // `.github/instructions/<name>` has no `.mdc`/`.instructions.md` extension
-            // and no frontmatter (`alwaysApply`/`applyTo`) — neither Cursor nor Copilot
-            // would ever read it. This must keep throwing, same as codex-agent-toml
-            // always has, directing users to commands/add.ts's real render pipeline
-            // instead (which never calls assertLinkRenderer at all).
-            expect(() => (0, providers_1.assertLinkRenderer)('skill', 'cursor')).toThrow(/not implemented yet/);
+        it('assertLinkRenderer accepts Cursor link skills and still refuses Copilot', () => {
+            expect(() => (0, providers_1.assertLinkRenderer)('skill', 'cursor')).not.toThrow();
+            expect((0, providers_1.assertLinkRenderer)('skill', 'cursor')?.renderer).toBe('link');
+            // Copilot still renders via the add pipeline only — a raw SKILL.md under
+            // `.github/instructions/` lacks `.instructions.md` + applyTo frontmatter.
             expect(() => (0, providers_1.assertLinkRenderer)('skill', 'copilot')).toThrow(/not implemented yet/);
         });
     });

package/dist/tests/structural/provider-paths-honor-config-home.test.js

@@ -86,11 +86,12 @@ describe('a provider that declares a config-home override honors it everywhere',
         });
     }
     it('shared, cross-agent conventions are NOT moved by one agent’s override', () => {
-        // `~/.agents/skills` lo comparten Codex y OpenCode: es del ecosistema, no de un
-        // agente. Moverlo con CODEX_HOME desconectaria a OpenCode de sus propias skills.
+        // `~/.agents/skills` lo comparten Codex, OpenCode y Cursor: es del ecosistema, no de un
+        // agente. Moverlo con CODEX_HOME desconectaria a OpenCode/Cursor de sus propias skills.
         const moved = providersWith({ HOME, CODEX_HOME: ELSEWHERE });
         expect(moved.codex.skill.global).toBe(path_1.default.join(HOME, '.agents/skills'));
         expect(moved.opencode.skill.global).toBe(path_1.default.join(HOME, '.agents/skills'));
+        expect(moved.cursor.skill.global).toBe(path_1.default.join(HOME, '.agents/skills'));
     });
     it('every agent declares a config home, so a new provider cannot skip the question', () => {
         const table = providersWith({ HOME });