agentic-workflow-manager 3.10.0 → 3.12.0

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

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/diagnostics/provider-tier.test.ts
+//
+// Task 4.4 — capability tier. Three concerns:
+//
+// 1. `providerTier` — a pure structural classification derived from each
+//    provider's config shape (hooks / injection / neither).
+// 2. `contextGlobalCheck`'s scope-awareness fix (deferred Task 4.2 finding):
+//    a `managed-agents-md` provider with `injection.globalPath === null`
+//    (Cursor, Copilot) operates at LOCAL scope, not global — asking
+//    `contextStatus` about 'global' for these providers always resolved to
+//    'absent' regardless of whether the local injection actually succeeded.
+// 3. `skillsGlobalCheck`'s renderer-awareness fix (deferred Task 4.3 finding):
+//    `classifyGlobalSkills` only ever sees symlinks, so a rendered format
+//    (cursor-mdc, copilot-instructions) always scanned as "0 broken" and
+//    reported a false-green 'healthy' regardless of what was actually on
+//    disk. Non-'link' renderers now report presence-only, honestly.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../../src/providers");
+const provider_checks_1 = require("../../../src/core/diagnostics/provider-checks");
+describe('providerTier — pure structural classification', () => {
+    const expected = {
+        antigravity: 'context-only',
+        opencode: 'config-managed',
+        'claude-code': 'hooks-native',
+        codex: 'hooks-native',
+        cursor: 'agents-md-managed',
+        copilot: 'agents-md-managed',
+    };
+    it.each(providers_1.AGENT_TARGETS)('%s', (agent) => {
+        expect((0, provider_checks_1.providerTier)((0, providers_1.providers)()[agent])).toBe(expected[agent]);
+    });
+});
+describe('contextGlobalCheck — scope-aware (Task 4.4 / deferred Task 4.2 finding)', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    const projectRoots = [];
+    function seedRegistry() {
+        const root = path_1.default.join(tmpHome, '.awm/registries/baseline');
+        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.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm/registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.invalid/baseline.git' }], null, 2));
+        return root;
+    }
+    function scanSkillsStub() {
+        return jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
+    }
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-tier-home-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        // registries.ts caches AWM_HOME as a module-level const AT REQUIRE TIME (see its own
+        // top comment). A static top-level import of gatherProviderChecks (which transitively
+        // requires registries.ts) would bake in whatever AWM_HOME was set BEFORE this
+        // beforeEach ever ran, silently resolving capabilityRoot() against the real machine's
+        // ~/.awm instead of tmpHome. Every module that (transitively) touches AWM_HOME/HOME
+        // must therefore be require()'d fresh, per test, after the env vars above are set —
+        // same pattern as tests/core/diagnostics/provider-checks.test.ts.
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        for (const p of projectRoots.splice(0))
+            fs_1.default.rmSync(p, { 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('Cursor (local scope, globalPath === null) reports delivered when local injection actually succeeded', () => {
+        const contentDir = seedRegistry();
+        const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-tier-project-'));
+        projectRoots.push(projectRoot);
+        const { InjectionOrchestrator } = require('../../../src/core/context/orchestrator');
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        new InjectionOrchestrator().installContext({
+            agent: 'cursor',
+            scope: 'local',
+            registryRoot: contentDir,
+            installMethod: 'symlink',
+            profileExtensions: [],
+            projectRoot,
+        });
+        const facts = gatherProviderChecks(['cursor'], scanSkillsStub(), projectRoot);
+        const contextCheck = facts[0].checks.find((c) => c.id === 'context.global');
+        expect(contextCheck).toMatchObject({ id: 'context.global', state: 'delivered' });
+    });
+    it('Copilot (local scope, globalPath === null) reports delivered when local injection actually succeeded', () => {
+        const contentDir = seedRegistry();
+        const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-tier-project-'));
+        projectRoots.push(projectRoot);
+        const { InjectionOrchestrator } = require('../../../src/core/context/orchestrator');
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        new InjectionOrchestrator().installContext({
+            agent: 'copilot',
+            scope: 'local',
+            registryRoot: contentDir,
+            installMethod: 'symlink',
+            profileExtensions: [],
+            projectRoot,
+        });
+        const facts = gatherProviderChecks(['copilot'], scanSkillsStub(), projectRoot);
+        const contextCheck = facts[0].checks.find((c) => c.id === 'context.global');
+        expect(contextCheck).toMatchObject({ id: 'context.global', state: 'delivered' });
+    });
+    it('Cursor without a resolvable projectRoot falls back to absent, not a crash', () => {
+        seedRegistry();
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        const facts = gatherProviderChecks(['cursor'], scanSkillsStub(), undefined);
+        const contextCheck = facts[0].checks.find((c) => c.id === 'context.global');
+        expect(contextCheck).toMatchObject({ id: 'context.global', state: 'absent', remediationCode: 'awm-init' });
+    });
+    it('Codex (global scope, unchanged) still resolves correctly — regression', () => {
+        const contentDir = seedRegistry();
+        const { InjectionOrchestrator } = require('../../../src/core/context/orchestrator');
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        new InjectionOrchestrator().installContext({
+            agent: 'codex',
+            scope: 'global',
+            registryRoot: contentDir,
+            installMethod: 'symlink',
+            profileExtensions: [],
+        });
+        const facts = gatherProviderChecks(['codex'], scanSkillsStub());
+        const contextCheck = facts[0].checks.find((c) => c.id === 'context.global');
+        expect(contextCheck).toMatchObject({ id: 'context.global', state: 'delivered' });
+    });
+    it('Codex with nothing installed reports absent — regression (pre-existing behavior)', () => {
+        seedRegistry();
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        const facts = gatherProviderChecks(['codex'], scanSkillsStub());
+        const contextCheck = facts[0].checks.find((c) => c.id === 'context.global');
+        expect(contextCheck).toMatchObject({ id: 'context.global', state: 'absent', remediationCode: 'awm-init' });
+    });
+});
+describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 finding)', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-tier-skills-'));
+        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(); // see contextGlobalCheck describe above for why
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { 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('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.');
+        // classifyGlobalSkills only ever sees symlinks (`if (!lst.isSymbolicLink()) continue;`)
+        // — a real scan over rulesDir would find nothing here either. Stubbed explicitly so the
+        // test proves the FIX (renderer-gating), not an accident of what classifyGlobalSkills does.
+        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
+        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');
+        expect(skillsCheck?.detail).toContain('not verified');
+    });
+    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.
+        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-'));
+        fs_1.default.mkdirSync(path_1.default.join(content, 'bundles', 'dev-core'), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(content, 'skills', 'using-awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(content, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\ndescription: Use when starting any development conversation\n---\n\nMUST invoke skills.\n');
+        fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({
+            version: 1,
+            bundles: [{ name: 'dev-core', source: './bundles/dev-core', version: '1.0.0', scope: 'baseline' }],
+        }));
+        fs_1.default.writeFileSync(path_1.default.join(content, 'bundles', 'dev-core', 'bundle.json'), JSON.stringify({
+            name: 'dev-core', version: '1.0.0', description: '', scope: 'baseline',
+            dependsOn: [], skills: ['using-awm'], workflows: [], agents: [],
+        }));
+        installBundle({
+            bundleName: 'dev-core',
+            bundles: discoverBundles(content),
+            agents: ['cursor'],
+            method: 'symlink',
+            projectRoot: tmpHome, // irrelevant for a global-scope install
+            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: [] }));
+        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 });
+        expect(skillsCheck?.detail).toContain('not verified');
+        fs_1.default.rmSync(content, { recursive: true, force: true });
+    });
+    it('non-link renderer with an empty/missing dir reports absent, not a false healthy', () => {
+        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
+        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('link renderer (claude-code) behavior is completely unchanged — regression', () => {
+        const skillsDir = path_1.default.join(tmpHome, '.claude/skills');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        const scanSkills = jest.fn(() => ({ valid: ['using-awm'], repairable: [], dead: [] }));
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        const facts = gatherProviderChecks(['claude-code'], scanSkills);
+        const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
+        expect(skillsCheck).toMatchObject({ id: 'skills.global', state: 'healthy', target: skillsDir });
+        expect(skillsCheck?.detail).toBeUndefined();
+    });
+    it('link renderer (claude-code) still reports broken links — regression', () => {
+        const skillsDir = path_1.default.join(tmpHome, '.claude/skills');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        const scanSkills = jest.fn(() => ({ valid: [], repairable: ['stale-skill'], dead: [] }));
+        const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
+        const facts = gatherProviderChecks(['claude-code'], scanSkills);
+        const skillsCheck = facts[0].checks.find((c) => c.id === 'skills.global');
+        expect(skillsCheck).toMatchObject({
+            id: 'skills.global',
+            state: 'broken',
+            detail: '1 broken links',
+            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', () => {
+            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: [] }));
+            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: [] }));
+            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' });
+        });
+        // 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.
+    });
+});

package/dist/tests/core/init/mutation-targets.test.js

@@ -19,6 +19,7 @@ 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 materializer_1 = require("../../../src/core/context/materializer");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
@@ -146,6 +147,8 @@ describe('planInitMutationTargets', () => {
             ];
             const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
             const skillsDir = providerFor('claude-code').skill.global;
+            if (skillsDir === null)
+                throw new Error('claude-code skill.global must not be null');
             expect(targets).toContain(path_1.default.join(skillsDir, 'using-awm'));
             expect(targets).toContain(path_1.default.join(skillsDir, 'ambient-skill'));
             // project-scope bundles are only enumerated via .awm/profile.json
@@ -192,6 +195,55 @@ describe('planInitMutationTargets', () => {
             expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'profile.json')))).toBe(false);
             expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'sensors.json')))).toBe(false);
         });
+        it('includes the materialized .awm/context/awm-context.md path for a local-scope-context provider (cursor)', () => {
+            // Finding: stepContextInjection (steps.ts) materializes its source content
+            // under <projectRoot>/.awm/context/awm-context.md BEFORE injecting it into
+            // the local AGENTS.md/.mdc target, for any provider whose managed-agents-md
+            // injection has no global path (globalPath === null). That materialized
+            // write is a real one this run can make and must be covered by the backup
+            // session, same reasoning as the target file itself just below.
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            const provider = providerFor('cursor');
+            expect(provider.injection?.type).toBe('managed-agents-md');
+            expect(provider.injection.globalPath).toBeNull();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'cursor', bundles: [] });
+            expect(targets).toContain((0, materializer_1.projectContextPath)(projectRoot));
+        });
+        it('includes the materialized .awm/context/awm-context.md path for a local-scope-context provider (copilot)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            const provider = providerFor('copilot');
+            expect(provider.injection?.type).toBe('managed-agents-md');
+            expect(provider.injection.globalPath).toBeNull();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'copilot', bundles: [] });
+            expect(targets).toContain((0, materializer_1.projectContextPath)(projectRoot));
+        });
+        it('does NOT include the materialized .awm/context/awm-context.md path for a global-scope-context provider (codex)', () => {
+            // Codex's managed-agents-md injection has a non-null globalPath, so its
+            // context is delivered at GLOBAL scope — the local materialized-source
+            // path is never written for it and must not be enumerated.
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            const provider = providerFor('codex');
+            expect(provider.injection.globalPath).not.toBeNull();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'codex', bundles: [] });
+            expect(targets).not.toContain((0, materializer_1.projectContextPath)(projectRoot));
+        });
+        it('includes .cursor/rules/awm.mdc (the redundant carrier) only for agent === cursor', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            const cursorTargets = planInitMutationTargets({ cwd: projectRoot, agent: 'cursor', bundles: [] });
+            expect(cursorTargets).toContain(path_1.default.join(projectRoot, '.cursor', 'rules', 'awm.mdc'));
+        });
+        it('does NOT include .cursor/rules/awm.mdc for copilot or other agents', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            for (const agent of ['copilot', 'codex', 'claude-code', 'opencode', 'antigravity']) {
+                const targets = planInitMutationTargets({ cwd: projectRoot, agent, bundles: [] });
+                expect(targets).not.toContain(path_1.default.join(projectRoot, '.cursor', 'rules', 'awm.mdc'));
+            }
+        });
         it('ignores an extension named in the profile that no longer resolves to a known bundle', () => {
             const { planInitMutationTargets, providerFor } = load();
             const projectRoot = makeProjectRoot();
@@ -212,6 +264,15 @@ describe('planInitMutationTargets', () => {
                 expect(targets).toContain(providerFor(agent).skill.global);
             }
         });
+        it('Gap C — adds no global skills-directory target for an agent whose skill.global is null (copilot), and does not crash', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            expect(providerFor('copilot').skill.global).toBeNull();
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'copilot', bundles: [] });
+            // No null ever lands in the returned target list, and nothing crashes
+            // trying to path.join/backup a null skills directory.
+            expect(targets).not.toContain(null);
+            expect(targets.every((t) => typeof t === 'string')).toBe(true);
+        });
         it('the skills-directory target covers orphaned entries repairGlobalSkills would mutate, not just bundle-derived subpaths', () => {
             // Regression guard for the logic gap: before the fix, only
             // bundle-DERIVED skill paths (e.g. .../skills/using-awm) were
@@ -225,6 +286,8 @@ describe('planInitMutationTargets', () => {
             const bundles = [bundle('dev-core', 'baseline', ['using-awm'])];
             const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
             const skillsDir = providerFor('claude-code').skill.global;
+            if (skillsDir === null)
+                throw new Error('claude-code skill.global must not be null');
             expect(targets).toContain(skillsDir);
             // Sanity: the orphan path itself is a child of the now-covered dir,
             // even though it is never separately enumerated.

package/dist/tests/core/init/provider-facts.test.js

@@ -74,6 +74,22 @@ describe('gatherProviderFacts / assertClaudeBaselinePreserved', () => {
         const after = gatherProviderFacts('claude-code');
         expect(before.hash).not.toBe(after.hash);
     });
+    it('Gap C — gatherProviderFacts skips a null skill.global (copilot) cleanly instead of crashing', () => {
+        const { gatherProviderFacts } = require('../../../src/core/init/provider-facts');
+        const { providerFor } = require('../../../src/providers');
+        expect(providerFor('copilot').skill.global).toBeNull();
+        const { assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const facts = gatherProviderFacts('copilot');
+        // providerManagedPaths guards `provider.skill.global !== null` (and every
+        // other managed path copilot lacks: no hooks, no global injection, no
+        // workflow/agent config) before adding anything — copilot manages NOTHING
+        // at the machine level, so the inspected path list is empty, and the call
+        // itself must not throw.
+        expect(facts.paths).toEqual([]);
+        expect(typeof facts.hash).toBe('string');
+        // Two snapshots of the same (empty) state are still identical/no-throw.
+        expect(() => assertClaudeBaselinePreserved(facts, facts)).not.toThrow();
+    });
     it('throws a distinct message when comparing facts for mismatched agents', () => {
         const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
         const claude = gatherProviderFacts('claude-code');

package/dist/tests/core/init/steps.test.js

@@ -389,6 +389,17 @@ describe('stepGlobalSkillsRepair', () => {
         expect(r.action).toBe('applied');
         expect(a.repairGlobalSkills).toHaveBeenCalledWith((0, providers_1.providerFor)('opencode').skill.global, expect.any(Array));
     });
+    it('Gap C — skips cleanly for an agent whose skill.global is null (copilot), even with broken links reported', () => {
+        const a = spies();
+        expect((0, providers_1.providerFor)('copilot').skill.global).toBeNull();
+        const m = machine();
+        // Broken-count is nonzero, so the ONLY thing that can make this skip is the
+        // null-global-dir guard itself, not the "nothing broken" early return above.
+        m.globalSkills = { valid: [], repairable: ['b'], dead: ['c'] };
+        const r = (0, steps_1.stepGlobalSkillsRepair)(deps({ machine: m, project: null }, a, { agent: 'copilot' }));
+        expect(r.action).toBe('skipped');
+        expect(a.repairGlobalSkills).not.toHaveBeenCalled();
+    });
 });
 describe('stepConstitutionInjection (#6)', () => {
     it('injects for a config-instructions agent when CONSTITUTION.md is present', () => {
@@ -464,4 +475,30 @@ describe('stepContextInjection', () => {
         expect(r.action).toBe('applied');
         expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'codex', scope: 'global' }));
     });
+    it('installs Copilot context at local scope with projectRoot (no global AGENTS.md-equivalent)', () => {
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/repo' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
+    });
+    it('regression: uses the discovered project root, not raw cwd, when awm init runs from a subdirectory (R4 QA blocker 2b)', () => {
+        // mutation-targets.ts's planInitMutationTargets computes its local-scope backup
+        // target via findProjectRoot(cwd), which walks UP from cwd to the real project
+        // root. If this step passed raw d.cwd as projectRoot instead, a run from a
+        // subdirectory would write to <cwd>/AGENTS.md while the backup session snapshotted
+        // <root>/AGENTS.md — a failed init's rollback would miss the real write entirely.
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: project({ root: '/repo' }) }, a, { agent: 'copilot', cwd: '/repo/packages/sub' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
+    });
+    it('falls back to raw cwd when no project was discovered', () => {
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/nowhere' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/nowhere' }));
+    });
 });

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

@@ -71,6 +71,19 @@ describe('install-planner', () => {
             owners,
         };
     }
+    describe('agentsSharingSkillTarget', () => {
+        it('excludes a candidate that does not support this scope at all, instead of throwing', () => {
+            // Regression: used to call skillTargetDir(candidate, ...) unguarded
+            // inside .filter() — Copilot at 'global' throws (no global skill
+            // dir), which crashed the whole call for every OTHER candidate too.
+            const group = (0, install_planner_1.agentsSharingSkillTarget)('claude-code', ['claude-code', 'copilot'], 'global', tmpWork);
+            expect(group).toEqual(['claude-code']);
+        });
+        it('still finds real shared targets when a non-sharing, scope-unsupported candidate is also present', () => {
+            const group = (0, install_planner_1.agentsSharingSkillTarget)('opencode', ['opencode', 'codex', 'copilot'], 'global', tmpWork);
+            expect(group.sort()).toEqual(['codex', 'opencode']);
+        });
+    });
     describe('planInstall', () => {
         it('deduplicates the OpenCode/Codex physical skill write and reports both owners', () => {
             const plan = (0, install_planner_1.planInstall)({
@@ -105,6 +118,26 @@ describe('install-planner', () => {
             });
             expect(plan.operations[0].owners).toEqual(['codex']); // verifies R13
         });
+        it('does not crash when a provider with no global skill support (Copilot) is merely enabled, not selected', () => {
+            // Regression: assertCompleteSharedGroup's inner `enabled.filter(...)`
+            // used to call physicalTarget() unguarded for every enabled agent,
+            // including ones that don't support this scope at all (Copilot has
+            // no global skill directory — skill.global is null). That threw
+            // inside the filter callback, uncaught, crashing this ENTIRE
+            // install for claude-code even though Copilot has nothing to do
+            // with it — just having Copilot in enabledAgents (e.g. from an
+            // earlier local-scope install) broke every subsequent global
+            // install for every other agent.
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code', 'copilot'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations[0].owners).toEqual(['claude-code']);
+        });
         it('returns no operations for an empty artifacts array', () => {
             const plan = (0, install_planner_1.planInstall)({
                 artifacts: [],
@@ -186,6 +219,91 @@ describe('install-planner', () => {
                 method: 'symlink',
             })).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', () => {
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [skillArtifact('development-process')],
+                    selectedAgents: ['cursor'],
+                    enabledAgents: ['cursor'],
+                    scope: 'local',
+                    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');
+            });
+            it('renders the Copilot skill target with a .instructions.md extension (not .md.instructions.md)', () => {
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [skillArtifact('development-process')],
+                    selectedAgents: ['copilot'],
+                    enabledAgents: ['copilot'],
+                    scope: 'local',
+                    projectRoot: tmpWork,
+                    method: 'symlink',
+                });
+                expect(plan.operations[0].targetPath).toBe(path_1.default.join(tmpWork, '.github', 'instructions', 'development-process.instructions.md'));
+                expect(plan.operations[0].renderer).toBe('copilot-instructions');
+            });
+            it('strips an installName that already carries an extension before appending .instructions.md', () => {
+                const withExtension = {
+                    name: 'development-process',
+                    installName: 'development-process.md',
+                    type: 'skill',
+                    sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', 'development-process'),
+                };
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [withExtension],
+                    selectedAgents: ['copilot'],
+                    enabledAgents: ['copilot'],
+                    scope: 'local',
+                    projectRoot: tmpWork,
+                    method: 'symlink',
+                });
+                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")', () => {
+                // 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`.
+                const dottedName = {
+                    name: 'v1.2-migration',
+                    installName: 'v1.2-migration',
+                    type: 'skill',
+                    sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', 'v1.2-migration'),
+                };
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [dottedName],
+                    selectedAgents: ['cursor'],
+                    enabledAgents: ['cursor'],
+                    scope: 'local',
+                    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');
+            });
+            it('still strips a real trailing .md extension for Cursor (not v1.2-migration.md.mdc)', () => {
+                const withMdExtension = {
+                    name: 'using-awm',
+                    installName: 'using-awm.md',
+                    type: 'skill',
+                    sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', 'using-awm'),
+                };
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [withMdExtension],
+                    selectedAgents: ['cursor'],
+                    enabledAgents: ['cursor'],
+                    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');
+            });
+        });
     });
     describe('planRemoval', () => {
         it('retains a target while a non-selected enabled owner remains', () => {