agentic-workflow-manager 3.11.0 → 3.13.0

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

@@ -38,9 +38,7 @@ describe('CodexAgentsStrategy', () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.codex'), { recursive: true });
         const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
         fs_1.default.writeFileSync(file, '# Personal\n\nDo not delete.\n');
-        const result = new codex_agents_1.CodexAgentsStrategy().injectGlobal({
-            markdown: '# AWM\n\nUse `development-process`.',
-        });
+        const result = new codex_agents_1.CodexAgentsStrategy().injectGlobal({ markdown: '# AWM\n\nUse `development-process`.' }, codexProvider(file));
         expect(result).toBe('injected');
         const written = fs_1.default.readFileSync(file, 'utf8');
         expect(written).toContain('# Personal\n\nDo not delete.\n');
@@ -48,18 +46,20 @@ describe('CodexAgentsStrategy', () => {
     });
     it('creates the global file and returns unchanged on an idempotent repeat', () => {
         const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        const provider = codexProvider(file);
         const context = { markdown: '# AWM\n\nBootstrap.' };
-        expect(strategy.injectGlobal(context)).toBe('injected');
-        expect(strategy.injectGlobal(context)).toBe('unchanged');
-        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.codex/AGENTS.md'))).toBe(true);
+        expect(strategy.injectGlobal(context, provider)).toBe('injected');
+        expect(strategy.injectGlobal(context, provider)).toBe('unchanged');
+        expect(fs_1.default.existsSync(file)).toBe(true);
     });
     it('uses HOME at call time', () => {
         const firstHome = tmpHome;
         const secondHome = path_1.default.join(tmpWork, 'second-home');
         const strategy = new codex_agents_1.CodexAgentsStrategy();
-        strategy.injectGlobal({ markdown: 'first' });
+        strategy.injectGlobal({ markdown: 'first' }, codexProvider(path_1.default.join(firstHome, '.codex/AGENTS.md')));
         process.env.HOME = secondHome;
-        strategy.injectGlobal({ markdown: 'second' });
+        strategy.injectGlobal({ markdown: 'second' }, codexProvider(path_1.default.join(secondHome, '.codex/AGENTS.md')));
         expect(fs_1.default.readFileSync(path_1.default.join(firstHome, '.codex/AGENTS.md'), 'utf8')).toContain('first');
         expect(fs_1.default.readFileSync(path_1.default.join(secondHome, '.codex/AGENTS.md'), 'utf8')).toContain('second');
     });
@@ -68,9 +68,10 @@ describe('CodexAgentsStrategy', () => {
         fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
         fs_1.default.writeFileSync(file, 'before\n');
         const strategy = new codex_agents_1.CodexAgentsStrategy();
-        strategy.injectGlobal({ markdown: 'old' });
+        const provider = codexProvider(file);
+        strategy.injectGlobal({ markdown: 'old' }, provider);
         fs_1.default.appendFileSync(file, 'after\n');
-        strategy.injectGlobal({ markdown: 'new' });
+        strategy.injectGlobal({ markdown: 'new' }, provider);
         expect(fs_1.default.readFileSync(file, 'utf8')).toBe('before\n\n<!-- AWM:START -->\n<!-- AWM:BOUNDARY prefix=1 suffix=1 -->\nnew\n<!-- AWM:END -->\nafter\n');
     });
     it('fails on ambiguous global markers without changing the file', () => {
@@ -78,7 +79,7 @@ describe('CodexAgentsStrategy', () => {
         fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
         const ambiguous = '<!-- AWM:START -->\nuser';
         fs_1.default.writeFileSync(file, ambiguous);
-        expect(() => new codex_agents_1.CodexAgentsStrategy().injectGlobal({ markdown: 'new' })).toThrow('unmatched');
+        expect(() => new codex_agents_1.CodexAgentsStrategy().injectGlobal({ markdown: 'new' }, codexProvider(file))).toThrow('unmatched');
         expect(fs_1.default.readFileSync(file, 'utf8')).toBe(ambiguous);
     });
     it('rejects inline marker examples without changing the global file', () => {
@@ -86,7 +87,7 @@ describe('CodexAgentsStrategy', () => {
         fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
         const ambiguous = '`<!-- AWM:START -->` example and `<!-- AWM:END -->` example';
         fs_1.default.writeFileSync(file, ambiguous);
-        expect(() => new codex_agents_1.CodexAgentsStrategy().injectGlobal({ markdown: 'new' })).toThrow('standalone');
+        expect(() => new codex_agents_1.CodexAgentsStrategy().injectGlobal({ markdown: 'new' }, codexProvider(file))).toThrow('standalone');
         expect(fs_1.default.readFileSync(file, 'utf8')).toBe(ambiguous);
     });
     it.each([
@@ -117,7 +118,7 @@ describe('CodexAgentsStrategy', () => {
         fs_1.default.mkdirSync(project, { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(project, 'CONSTITUTION.md'), '# Rules\n');
         fs_1.default.writeFileSync(path_1.default.join(project, 'AGENTS.md'), '# Repo-owned rules\n');
-        const result = new codex_agents_1.CodexAgentsStrategy().injectProject(project);
+        const result = new codex_agents_1.CodexAgentsStrategy().injectProject(project, codexProvider(path_1.default.join(tmpHome, '.codex/AGENTS.md')));
         expect(result).toBe('injected');
         const written = fs_1.default.readFileSync(path_1.default.join(project, 'AGENTS.md'), 'utf8');
         expect(written).toContain('# Repo-owned rules');
@@ -127,11 +128,74 @@ describe('CodexAgentsStrategy', () => {
         const project = path_1.default.join(tmpWork, 'repo');
         fs_1.default.mkdirSync(project, { recursive: true });
         const strategy = new codex_agents_1.CodexAgentsStrategy();
-        expect(strategy.injectProject(project)).toBe('injected');
-        expect(strategy.injectProject(project)).toBe('unchanged');
+        const provider = codexProvider(path_1.default.join(tmpHome, '.codex/AGENTS.md'));
+        expect(strategy.injectProject(project, provider)).toBe('injected');
+        expect(strategy.injectProject(project, provider)).toBe('unchanged');
         expect(fs_1.default.readFileSync(path_1.default.join(project, 'AGENTS.md'), 'utf8'))
             .toContain('when that file exists');
     });
+    it('injectProject writes a redundant .cursor/rules/awm.mdc carrier (alwaysApply: true) for Cursor, and skips its own AGENTS.md write (owned by inject(), see collision regression below)', () => {
+        const project = path_1.default.join(tmpWork, 'cursor-repo');
+        fs_1.default.mkdirSync(project, { recursive: true });
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const result = strategy.injectProject(project, cursorProvider(), 'cursor');
+        expect(result).toBe('injected');
+        expect(fs_1.default.existsSync(path_1.default.join(project, 'AGENTS.md'))).toBe(false);
+        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');
+    });
+    it('injectProject writes only AGENTS.md (no .cursor/rules) for a provider whose context injection is a SEPARATE (global) file', () => {
+        const project = path_1.default.join(tmpWork, 'codex-project-repo');
+        fs_1.default.mkdirSync(project, { recursive: true });
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        strategy.injectProject(project, codexProvider(path_1.default.join(tmpHome, '.codex/AGENTS.md')));
+        expect(fs_1.default.existsSync(path_1.default.join(project, 'AGENTS.md'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(project, '.cursor'))).toBe(false);
+    });
+    it('injectProject writes NEITHER AGENTS.md NOR a carrier for Copilot (local-context provider, no carrier mechanism)', () => {
+        const project = path_1.default.join(tmpWork, 'copilot-repo');
+        fs_1.default.mkdirSync(project, { recursive: true });
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const result = strategy.injectProject(project, copilotProvider(), 'copilot');
+        expect(result).toBe('unchanged');
+        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');
+        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 = cursorProvider();
+        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: 'cursor',
+            scope: 'local',
+            projectRoot: project,
+        };
+        expect(strategy.inject(input, provider)).toBe('injected');
+        expect(strategy.injectProject(project, provider, 'cursor')).toBe('injected'); // carrier only
+        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');
+        // Idempotent: a second full pass (context re-inject, then constitution/carrier) changes nothing.
+        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('implements global status and remove while preserving user bytes', () => {
         const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
         const materialized = path_1.default.join(tmpWork, 'awm-context.md');
@@ -155,15 +219,70 @@ describe('CodexAgentsStrategy', () => {
     });
     it('validates public inputs and never writes outside the configured roots', () => {
         const strategy = new codex_agents_1.CodexAgentsStrategy();
-        expect(() => strategy.injectGlobal({ markdown: '' })).toThrow('markdown');
-        expect(() => strategy.injectGlobal(null)).toThrow('context');
-        expect(() => strategy.injectProject('')).toThrow('projectRoot');
+        const provider = codexProvider(path_1.default.join(tmpHome, '.codex/AGENTS.md'));
+        expect(() => strategy.injectGlobal({ markdown: '' }, provider)).toThrow('markdown');
+        expect(() => strategy.injectGlobal(null, provider)).toThrow('context');
+        expect(() => strategy.injectProject('', provider)).toThrow('projectRoot');
         const open = jest.spyOn(fs_1.default, 'openSync');
-        strategy.injectGlobal({ markdown: 'safe' });
-        strategy.injectProject(path_1.default.join(tmpWork, 'safe-project'));
+        strategy.injectGlobal({ markdown: 'safe' }, provider);
+        strategy.injectProject(path_1.default.join(tmpWork, 'safe-project'), provider);
         const opened = open.mock.calls.map((call) => String(call[0]));
         expect(opened.every((file) => file.startsWith(tmpHome) || file.startsWith(tmpWork))).toBe(true);
     });
+    it('regression: Codex (non-null globalPath) still requires global scope — unchanged behavior', () => {
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        const materialized = path_1.default.join(tmpWork, 'awm-context.md');
+        const markdown = '# AWM\n\nExpected.';
+        fs_1.default.writeFileSync(materialized, markdown);
+        const provider = codexProvider(file);
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const localInput = {
+            ref: { absPath: materialized, scope: 'local', contentHash: (0, provider_1.sha256)(markdown) },
+            registryRoot: '/registry',
+            installMethod: 'copy',
+            agent: 'codex',
+            scope: 'local',
+            projectRoot: tmpWork,
+        };
+        expect(() => strategy.inject(localInput, provider)).toThrow('supports only global injection');
+        expect(fs_1.default.existsSync(file)).toBe(false);
+    });
+    it('Copilot-shaped provider (null globalPath): inject() at scope local writes <projectRoot>/AGENTS.md, not any global path', () => {
+        const project = path_1.default.join(tmpWork, 'copilot-local-repo');
+        fs_1.default.mkdirSync(project, { recursive: true });
+        const materialized = path_1.default.join(tmpWork, 'awm-context.md');
+        const markdown = '# AWM\n\nCopilot body.';
+        fs_1.default.writeFileSync(materialized, markdown);
+        const provider = copilotProvider();
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const input = {
+            ref: { absPath: materialized, scope: 'local', contentHash: (0, provider_1.sha256)(markdown) },
+            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('Copilot body.');
+        expect(strategy.status(input, provider)).toBe('injected');
+    });
+    it('Copilot-shaped provider (null globalPath): calling at scope global throws (required scope is local)', () => {
+        const materialized = path_1.default.join(tmpWork, 'awm-context.md');
+        const markdown = '# AWM\n\nBody.';
+        fs_1.default.writeFileSync(materialized, markdown);
+        const provider = copilotProvider();
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const globalInput = {
+            ref: { absPath: materialized, scope: 'global', contentHash: (0, provider_1.sha256)(markdown) },
+            registryRoot: '/registry',
+            installMethod: 'copy',
+            agent: 'copilot',
+            scope: 'global',
+        };
+        expect(() => strategy.inject(globalInput, provider)).toThrow('supports only local injection');
+    });
 });
 function codexProvider(globalPath) {
     return {
@@ -174,6 +293,24 @@ function codexProvider(globalPath) {
         injection: { type: 'managed-agents-md', globalPath, localFile: 'AGENTS.md' },
     };
 }
+function copilotProvider() {
+    return {
+        label: 'Copilot',
+        skill: { global: null, local: '.github/instructions', renderer: 'link' },
+        workflow: null,
+        agent: null,
+        injection: { type: 'managed-agents-md', globalPath: null, localFile: 'AGENTS.md' },
+    };
+}
+function cursorProvider() {
+    return {
+        label: 'Cursor',
+        skill: { global: '', local: '.cursor/rules', renderer: 'link' },
+        workflow: null,
+        agent: null,
+        injection: { type: 'managed-agents-md', globalPath: null, localFile: 'AGENTS.md' },
+    };
+}
 function injectionInput(absPath, markdown) {
     return {
         ref: { absPath, scope: 'global', contentHash: (0, provider_1.sha256)(markdown) },

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

@@ -190,6 +190,7 @@ describe('computeProviderOverall (Task 9)', () => {
         return {
             id: 'codex',
             label: 'Codex',
+            tier: 'hooks-native',
             checks: states.map((state, i) => ({ id: CHECK_IDS[i % CHECK_IDS.length], state })),
         };
     }

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