agentic-workflow-manager 9.14.1 → 9.15.1

package/dist/tests/commands/init.test.js

@@ -395,20 +395,22 @@ describe('runInit', () => {
         expect(JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf8'))).toEqual({ pristine: true, unrelated: 'keep' });
     });
     // -----------------------------------------------------------------------
-    // Gap A (QA panel) — GLOBAL-scope render pipeline for Cursor/Copilot was
-    // only ever exercised via LOCAL-scope `awm add`/bundle-install tests
-    // (tests/core/bundle-install.test.ts). This drives a real `awm init
-    // --agent cursor` through the REAL installBundle/applyInstallPlan path
-    // (no installBundle override — only syncCache is stubbed, to avoid a
-    // real network clone) and asserts a real rendered .mdc file lands in the
-    // GLOBAL ~/.cursor/rules directory with the expected frontmatter shape.
+    // Gap A (QA panel) — GLOBAL-scope Cursor skill delivery. Plan B installs
+    // Cursor skills as links under ~/.agents/skills (shared with Codex/
+    // OpenCode) plus native hooks.json entries (registry floor >= 4.9.0).
+    // Drives a real `awm init --agent cursor` through installBundle/
+    // applyInstallPlan (only syncCache stubbed) and asserts the link + hooks.
     // -----------------------------------------------------------------------
-    it('Gap A — real global-scope render: awm init --agent cursor renders a real .mdc into ~/.cursor/rules', async () => {
+    it('Gap A — real global-scope link: awm init --agent cursor links using-awm into ~/.agents/skills', async () => {
+        const { spawnSync } = require('child_process');
         const contentRoot = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');
-        // A 'hooks' dir (even empty) is what makes capabilityRoot('hooks') resolve to
-        // this content root — that's the registryRoot stepContextInjection uses to
-        // find skills/using-awm/SKILL.md for the (unrelated) context-injection step.
+        // A 'hooks' dir is what makes capabilityRoot('hooks') resolve to this content
+        // root — registryRoot for stepContextInjection / stepHook. Plan B also needs
+        // the three Cursor hook scripts and an exact v4.9.0+ tag for the registry floor.
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
+        for (const name of ['cursor-session-start', 'cursor-pre-compact', 'cursor-post-tool-use']) {
+            fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', name), '#!/usr/bin/env node\nconsole.log("{}")\n', { mode: 0o755 });
+        }
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', 'using-awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\ndescription: Use when starting any development conversation\n---\n\nMUST invoke skills per the tiered policy.\n');
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'bundles', 'dev-core'), { recursive: true });
@@ -420,6 +422,10 @@ describe('runInit', () => {
             name: 'dev-core', version: '1.0.0', description: 'Baseline', scope: 'baseline',
             dependsOn: [], skills: ['using-awm'], workflows: [], agents: [],
         }));
+        spawnSync('git', ['init', '-q', '-b', 'main'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'add', '.'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-qm', 'fixture'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['tag', 'v4.9.0'], { cwd: contentRoot, stdio: 'ignore' });
         const projectCwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-cursor-cwd-'));
         try {
             const { runInit } = require('../../src/commands/init');
@@ -431,20 +437,15 @@ describe('runInit', () => {
                 // seedBaselineRegistry() writes registries.json pointing at 'baseline'
                 // (our manually-seeded content root above) since none exists yet — no
                 // real network clone happens because that content root already exists
-                // on disk. Only syncCache is stubbed, so stepCache's own sync (the
-                // content root above has no `.git`, so it reads as "not yet cloned")
-                // doesn't try to shell out to git either.
+                // on disk. Only syncCache is stubbed.
                 actions: { syncCache: async () => { } },
             });
             expect(code).toBeLessThanOrEqual(1);
-            const mdcPath = path_1.default.join(tmpHome, '.cursor', 'rules', 'using-awm.mdc');
-            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'rules', 'using-awm'))).toBe(false);
-            expect(fs_1.default.existsSync(mdcPath)).toBe(true);
-            const rendered = fs_1.default.readFileSync(mdcPath, 'utf8');
-            expect(rendered).toContain('description: Use when starting any development conversation');
-            expect(rendered).toContain('globs:');
-            expect(rendered).toContain('alwaysApply: false');
-            expect(rendered).toContain('MUST invoke skills per the tiered policy.');
+            const linked = path_1.default.join(tmpHome, '.agents', 'skills', 'using-awm');
+            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'rules', 'using-awm.mdc'))).toBe(false);
+            expect(fs_1.default.lstatSync(linked).isSymbolicLink() || fs_1.default.existsSync(path_1.default.join(linked, 'SKILL.md'))).toBe(true);
+            expect(fs_1.default.readFileSync(path_1.default.join(linked, 'SKILL.md'), 'utf8')).toContain('MUST invoke skills per the tiered policy.');
+            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'hooks.json'))).toBe(true);
         }
         finally {
             fs_1.default.rmSync(projectCwd, { recursive: true, force: true });

package/dist/tests/commands/plan/index.test.js

@@ -488,7 +488,11 @@ describe('plan admit Commander wiring', () => {
             process.exitCode = undefined;
         }
     });
-    it.each([['cursor', 'global'], ['cursor', 'local'], ['copilot', 'local']])('does not prove absence for actual unowned rendered %s %s runtime contracts', async (target, scope) => {
+    // Cursor skills are link-installed under ~/.agents/skills (same as Codex); only
+    // content renderers still need this "rendered copy ≠ ownership" proof. Link
+    // unowned cases are covered by the runtime-unowned scenarios above.
+    it('does not prove absence for actual unowned rendered copilot local runtime contracts', async () => {
+        const target = 'copilot';
         const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rendered-admission-')));
         const oldHome = process.env.HOME;
         process.env.HOME = path_1.default.join(root, 'home');
@@ -500,7 +504,7 @@ describe('plan admit Commander wiring', () => {
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ minCliVersion: '1.0.0' }));
         fs_1.default.writeFileSync(path_1.default.join(root, 'source.md'), 'project source');
         const provider = (0, providers_1.providerFor)(target);
-        const directory = scope === 'global' ? provider.skill.global : path_1.default.resolve(root, provider.skill.local);
+        const directory = path_1.default.resolve(root, provider.skill.local);
         fs_1.default.mkdirSync(directory, { recursive: true });
         const installedFile = path_1.default.join(directory, (0, registry_1.renderedFilename)('using-awm', provider.skill.renderer));
         fs_1.default.writeFileSync(installedFile, (0, registry_1.renderArtifact)(provider.skill.renderer, skillSource));
@@ -540,6 +544,56 @@ describe('plan admit Commander wiring', () => {
             process.exitCode = undefined;
         }
     });
+    it.each([['cursor', 'global'], ['cursor', 'local']])('does not prove absence for actual unowned linked %s %s runtime contracts', async (target, scope) => {
+        const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-linked-admission-')));
+        const oldHome = process.env.HOME;
+        process.env.HOME = path_1.default.join(root, 'home');
+        const outputSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const registryRoot = path_1.default.join(root, 'registry');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ minCliVersion: '1.0.0' }));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'source.md'), 'project source');
+        const unowned = path_1.default.join(root, 'unowned', 'using-awm');
+        fs_1.default.mkdirSync(unowned, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(unowned, 'SKILL.md'), '---\nname: using-awm\ndescription: contract\n---\nRuntime contract.\n');
+        const provider = (0, providers_1.providerFor)(target);
+        const directory = scope === 'global' ? provider.skill.global : path_1.default.resolve(root, provider.skill.local);
+        fs_1.default.mkdirSync(directory, { recursive: true });
+        const artifact = path_1.default.join(directory, (0, registry_1.renderedFilename)('using-awm', provider.skill.renderer));
+        fs_1.default.symlinkSync(unowned, artifact, process.platform === 'win32' ? 'junction' : 'dir');
+        const sensors = jest.fn();
+        const program = new commander_1.Command();
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => ({ ...valid, manifest: { ...valid.manifest, sources: [{ id: 'source', path: 'source.md', locator: 'contract', fact: 'contract' }] } }),
+            listRegistries: () => [{ name: 'fixture', remote: 'https://example.invalid/fixture.git', contentRoot: registryRoot }],
+            readPreferences: () => ({ defaultAgent: target, enabledAgents: [target], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: async () => ({ checkedAt: 'x', compatibility: { status: 'not-checked' }, components: [{ component: 'cli', installed: '1.0.0', latest: '1.0.0', channel: 'stable', source: 'fixture', checkedAt: 'x', status: 'current', detail: 'ok', remedy: 'none' }] }),
+            runSensors: sensors,
+        });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', target, '--cwd', root, '--execution-mode', 'interactivo', '--require-current', '--verify-sensors', '--json']);
+            const output = JSON.parse(String(outputSpy.mock.calls.at(-1)[0]));
+            expect(output.diagnostics[0].code).toBe('ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED');
+            expect(output.state).toBe('blocked');
+            const reported = /^Runtime artifact (.+) has no unique physical registry owner/.exec(output.diagnostics[0].message);
+            expect(reported).not.toBeNull();
+            const reportedIdentity = fs_1.default.lstatSync(reported[1], { bigint: true });
+            const installedIdentity = fs_1.default.lstatSync(artifact, { bigint: true });
+            expect(reportedIdentity.isSymbolicLink() || reportedIdentity.isDirectory()).toBe(true);
+            expect(reportedIdentity.ino).not.toBe(0n);
+            expect([reportedIdentity.dev, reportedIdentity.ino]).toEqual([installedIdentity.dev, installedIdentity.ino]);
+            expect(sensors).not.toHaveBeenCalled();
+        }
+        finally {
+            if (oldHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = oldHome;
+            outputSpy.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
     it.each(['symlink', 'directory', 'oversized', 'duplicate-floor', 'unsafe-floor', 'stale-before-compatibility'])('keeps registry manifest %s noncertifying before sensors', async (scenario) => {
         const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-manifest-admission-')));
         const registryRoot = path_1.default.join(root, 'registry');

package/dist/tests/core/admission/index.test.js

@@ -177,6 +177,25 @@ describe('admitPlan', () => {
             expect(report.state).toBe('blocked');
             expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
         });
+        // While Camino B is suspended, a leftover journal on the branch must not
+        // trap native v1 unattended admission. Jest sets AWM_ALLOW_DURABLE_CUSTODY=1
+        // for the rest of the suite; this case restores the operator default.
+        it('ignores leftover journals for native v1 while durable custody is suspended', async () => {
+            const previous = process.env.AWM_ALLOW_DURABLE_CUSTODY;
+            delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+            try {
+                const corrupt = await (0, admission_1.admitPlan)({ ...base(), journalCorrupt: true });
+                expect(corrupt).toMatchObject({ state: 'admitted', executionMode: 'desatendido', journal: 'not-required' });
+                const stale = await (0, admission_1.admitPlan)({ ...base(), journalState: { ...(0, types_1.emptyState)('main'), schema: 2, planBinding: { path: 'docs/plan.md', digest: 'b'.repeat(64), schema: 'compact-slices/v1', executionMode: 'desatendido', boundAt: '2026-09-15T00:00:00.000Z' } } });
+                expect(stale).toMatchObject({ state: 'admitted', journal: 'not-required' });
+            }
+            finally {
+                if (previous === undefined)
+                    delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+                else
+                    process.env.AWM_ALLOW_DURABLE_CUSTODY = previous;
+            }
+        });
     });
     // R8: a content registry whose sensors are ALL deliberately disabled may close
     // work; its release proof lives in CI. The local verdict stays not-certified —

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

@@ -284,12 +284,8 @@ describe('installBundle', () => {
         expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.awm/profile.json'))).toBe(true);
         expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.gitignore'))).toBe(true);
     });
-    it('materializes a skill as a rendered Cursor .mdc via the real default applyInstallPlan (Task 4.3 e2e)', () => {
+    it('materializes a Cursor skill as a link under .agents/skills via the real default applyInstallPlan (Plan B e2e)', () => {
         const { content, projectRoot, bundles } = makeFixture();
-        // s-base's fixture SKILL.md (makeFixture, above) has no `description`
-        // field — real for a bare skill fixture, but cursor-mdc.ts's renderer
-        // requires one (parseSkillSource). Seed a real description here so
-        // this is a genuine end-to-end render, not just a source-existence check.
         fs_1.default.writeFileSync(path_1.default.join(content, 'skills', 's-base', 'SKILL.md'), '---\nname: s-base\ndescription: Base skill for bundle-install fixtures\n---\n\nDo the base thing.\n');
         const base = bundles.find((bundle) => bundle.name === 'base');
         const result = (0, bundle_install_1.installBundle)({
@@ -300,15 +296,12 @@ describe('installBundle', () => {
             projectRoot,
             contentDir: content,
         });
-        const mdcPath = path_1.default.join(projectRoot, '.cursor/rules/s-base.mdc');
-        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.cursor/rules/s-base'))).toBe(false);
-        expect(fs_1.default.existsSync(mdcPath)).toBe(true);
-        const rendered = fs_1.default.readFileSync(mdcPath, 'utf8');
-        expect(rendered).toContain('description: Base skill for bundle-install fixtures');
-        expect(rendered).toContain('alwaysApply: false');
-        expect(rendered).toContain('Do the base thing.');
+        const linked = path_1.default.join(projectRoot, '.agents/skills/s-base');
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.cursor/rules/s-base.mdc'))).toBe(false);
+        expect(fs_1.default.lstatSync(linked).isSymbolicLink() || fs_1.default.existsSync(path_1.default.join(linked, 'SKILL.md'))).toBe(true);
+        expect(fs_1.default.readFileSync(path_1.default.join(linked, 'SKILL.md'), 'utf8')).toContain('Do the base thing.');
         expect(result.transactionId).toBeTruthy();
-        expect(result.modifiedFiles).toContain(mdcPath);
+        expect(result.modifiedFiles).toContain(linked);
     });
     it('materializes a skill as rendered Copilot .instructions.md via the real default applyInstallPlan (Task 4.3 e2e)', () => {
         const { content, projectRoot, bundles } = makeFixture();
@@ -338,7 +331,8 @@ describe('installBundle', () => {
             bundleName: 'base', bundles, agents: ['cursor'],
             method: 'symlink', projectRoot, contentDir: content,
         });
-        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.cursor/rules/s-base.mdc'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.agents/skills/s-base'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.cursor/rules/s-base.mdc'))).toBe(false);
         expect(cursorResult.recordedExtension).toBe('base');
         const copilotResult = (0, bundle_install_1.addBundle)({
             bundleName: 'base', bundles, agents: ['copilot'],

package/dist/tests/core/context/strategies/codex-agents.test.js

@@ -162,14 +162,8 @@ describe('CodexAgentsStrategy', () => {
         expect(fs_1.default.existsSync(path_1.default.join(project, 'AGENTS.md'))).toBe(false);
         expect(fs_1.default.existsSync(path_1.default.join(project, '.cursor'))).toBe(false);
     });
-    it('regression: local-scope context injection + project constitution injection no longer collide on the same AGENTS.md managed block (R4 QA blocker)', () => {
-        // Before the fix: inject() (context) and injectProject() (constitution) both wrote
-        // the SAME single-slot managed block in <projectRoot>/AGENTS.md for a local-scope
-        // provider (Cursor/Copilot) — whichever ran second silently discarded the other's
-        // content. stepContextInjection runs before stepConstitutionInjection in the real
-        // init orchestrator (init/orchestrator.ts), so constitution always won, and the real
-        // AWM skill/context guidance never survived a real `awm init --agent cursor` run.
-        const project = path_1.default.join(tmpWork, 'collision-repo');
+    it('Cursor inject writes PROJECT_GUIDANCE only (using-awm lives in the hook — Plan B R4/R10)', () => {
+        const project = path_1.default.join(tmpWork, 'cursor-guidance-only');
         fs_1.default.mkdirSync(project, { recursive: true });
         const materialized = path_1.default.join(project, '.awm/context/awm-context.md');
         const contextMarkdown = '# AWM\n\nUse `development-process`. MUST invoke skills per policy.';
@@ -186,15 +180,40 @@ describe('CodexAgentsStrategy', () => {
             projectRoot: project,
         };
         expect(strategy.inject(input, provider)).toBe('injected');
-        expect(strategy.injectProject(project, provider, 'cursor')).toBe('injected'); // carrier only
+        expect(strategy.injectProject(project, provider, 'cursor')).toBe('injected'); // awm.mdc carrier
         const written = fs_1.default.readFileSync(path_1.default.join(project, 'AGENTS.md'), 'utf8');
-        expect(written).toContain('MUST invoke skills per policy');
         expect(written).toContain('Read and obey `CONSTITUTION.md` before work');
+        expect(written).not.toContain('MUST invoke skills');
+        expect(written).not.toContain('# AWM');
         expect(strategy.status(input, provider)).toBe('injected');
-        // Idempotent: a second full pass (context re-inject, then constitution/carrier) changes nothing.
+        const mdc = fs_1.default.readFileSync(path_1.default.join(project, '.cursor/rules/awm.mdc'), 'utf8');
+        expect(mdc).toContain('alwaysApply: true');
+        expect(mdc).toContain('Read and obey `CONSTITUTION.md` before work');
         expect(strategy.inject(input, provider)).toBe('unchanged');
         expect(strategy.injectProject(project, provider, 'cursor')).toBe('unchanged');
-        expect(fs_1.default.readFileSync(path_1.default.join(project, 'AGENTS.md'), 'utf8')).toBe(written);
+    });
+    it('Copilot inject still writes full using-awm plus PROJECT_GUIDANCE (sole carrier)', () => {
+        const project = path_1.default.join(tmpWork, 'copilot-full-context');
+        fs_1.default.mkdirSync(project, { recursive: true });
+        const materialized = path_1.default.join(project, '.awm/context/awm-context.md');
+        const contextMarkdown = '# AWM\n\nUse `development-process`. MUST invoke skills per policy.';
+        fs_1.default.mkdirSync(path_1.default.dirname(materialized), { recursive: true });
+        fs_1.default.writeFileSync(materialized, contextMarkdown);
+        const provider = copilotProvider();
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const input = {
+            ref: { absPath: materialized, scope: 'local', contentHash: (0, provider_1.sha256)(contextMarkdown) },
+            registryRoot: '/registry',
+            installMethod: 'copy',
+            agent: 'copilot',
+            scope: 'local',
+            projectRoot: project,
+        };
+        expect(strategy.inject(input, provider)).toBe('injected');
+        const written = fs_1.default.readFileSync(path_1.default.join(project, 'AGENTS.md'), 'utf8');
+        expect(written).toContain('MUST invoke skills per policy');
+        expect(written).toContain('Read and obey `CONSTITUTION.md` before work');
+        expect(strategy.status(input, provider)).toBe('injected');
     });
     it('implements global status and remove while preserving user bytes', () => {
         const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');

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']);
+    });
+});