agentic-workflow-manager 3.11.0 → 3.12.0

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

@@ -293,6 +293,62 @@ 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.
+    // -----------------------------------------------------------------------
+    it('Gap A — real global-scope render: awm init --agent cursor renders a real .mdc into ~/.cursor/rules', async () => {
+        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.
+        fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
+        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 });
+        fs_1.default.writeFileSync(path_1.default.join(contentRoot, '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(contentRoot, 'bundles', 'dev-core', 'bundle.json'), JSON.stringify({
+            name: 'dev-core', version: '1.0.0', description: 'Baseline', scope: 'baseline',
+            dependsOn: [], skills: ['using-awm'], workflows: [], agents: [],
+        }));
+        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');
+            const code = await runInit({
+                cwd: projectCwd,
+                agent: 'cursor',
+                yes: true,
+                machineOnly: true,
+                // 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.
+                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.');
+        }
+        finally {
+            fs_1.default.rmSync(projectCwd, { recursive: true, force: true });
+        }
+    });
+    // -----------------------------------------------------------------------
     // Failure evidence — `--json` must honour its contract on the ERROR path
     // -----------------------------------------------------------------------
     describe('failure evidence', () => {

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

@@ -248,6 +248,69 @@ 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)', () => {
+        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)({
+            bundleName: 'base',
+            bundles: [base],
+            agents: ['cursor'],
+            method: 'symlink',
+            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.');
+        expect(result.transactionId).toBeTruthy();
+        expect(result.modifiedFiles).toContain(mdcPath);
+    });
+    it('materializes a skill as rendered Copilot .instructions.md via the real default applyInstallPlan (Task 4.3 e2e)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        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)({
+            bundleName: 'base',
+            bundles: [base],
+            agents: ['copilot'],
+            method: 'symlink',
+            projectRoot,
+            contentDir: content,
+        });
+        const instructionsPath = path_1.default.join(projectRoot, '.github/instructions/s-base.instructions.md');
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.github/instructions/s-base'))).toBe(false);
+        expect(fs_1.default.existsSync(instructionsPath)).toBe(true);
+        const rendered = fs_1.default.readFileSync(instructionsPath, 'utf8');
+        expect(rendered).toContain('applyTo: "**"');
+        expect(rendered).toContain('Do the base thing.');
+        expect(result.transactionId).toBeTruthy();
+        expect(result.modifiedFiles).toContain(instructionsPath);
+    });
+    it('applies real filesystem changes for Cursor + Copilot via addBundle (awm add e2e, no applyPlan override)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        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 cursorResult = (0, bundle_install_1.addBundle)({
+            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(cursorResult.recordedExtension).toBe('base');
+        const copilotResult = (0, bundle_install_1.addBundle)({
+            bundleName: 'base', bundles, agents: ['copilot'],
+            method: 'symlink', projectRoot, contentDir: content,
+        });
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.github/instructions/s-base.instructions.md'))).toBe(true);
+        expect(copilotResult.recordedExtension).toBe('base');
+    });
     it('installs a skill shared by two agents (OpenCode + Codex) with exactly one replaceArtifact call, but the summary contains both providers', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const base = bundles.find((bundle) => bundle.name === 'base');

package/dist/tests/core/context/materializer.test.js

@@ -17,6 +17,14 @@ describe('globalContextPath', () => {
         expect((0, materializer_1.globalContextPath)()).toContain(path_1.default.join('context', 'awm-context.md'));
     });
 });
+describe('projectContextPath', () => {
+    it('points under <projectRoot>/.awm/context, mirroring globalContextPath\'s shape', () => {
+        expect((0, materializer_1.projectContextPath)('/repo')).toBe(path_1.default.join('/repo', '.awm', 'context', 'awm-context.md'));
+    });
+    it('differs from globalContextPath (distinct materialized-source paths per scope)', () => {
+        expect((0, materializer_1.projectContextPath)('/repo')).not.toBe((0, materializer_1.globalContextPath)());
+    });
+});
 describe('materialize', () => {
     it('writes the content and returns a ref with the matching hash', () => {
         const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mat-'));

package/dist/tests/core/context/orchestrator.test.js

@@ -8,6 +8,7 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const orchestrator_1 = require("../../../src/core/context/orchestrator");
+const materializer_1 = require("../../../src/core/context/materializer");
 jest.mock('../../../src/commands/hooks/install', () => ({ installHook: jest.fn() }));
 jest.mock('../../../src/commands/hooks/uninstall', () => ({ uninstallHook: jest.fn() }));
 jest.mock('../../../src/commands/hooks/status', () => ({
@@ -170,3 +171,53 @@ describe('InjectionOrchestrator (codex, managed AGENTS.md strategy)', () => {
         expect(fs_1.default.readFileSync(agentsPath, 'utf8')).toBe('# User rules\n');
     });
 });
+describe('InjectionOrchestrator (local scope materializes under the project, not ~/.awm)', () => {
+    let tmpHome;
+    let projectRoot;
+    let registryRoot;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-home-'));
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-proj-'));
+        registryRoot = tmpRegistry();
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+    });
+    afterEach(() => {
+        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;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+        fs_1.default.rmSync(registryRoot, { recursive: true, force: true });
+    });
+    it('materializes to projectContextPath(projectRoot) for scope local, never to globalContextPath()', () => {
+        const orch = new orchestrator_1.InjectionOrchestrator({
+            providerOverride: {
+                label: 'Copilot', skill: { global: null, local: '.github/instructions', renderer: 'link' }, workflow: null, agent: null,
+                injection: { type: 'managed-agents-md', globalPath: null, localFile: 'AGENTS.md' },
+            },
+        });
+        const op = {
+            agent: 'copilot',
+            scope: 'local',
+            registryRoot,
+            installMethod: 'copy',
+            profileExtensions: [],
+            projectRoot,
+        };
+        orch.installContext(op);
+        expect(fs_1.default.existsSync((0, materializer_1.projectContextPath)(projectRoot))).toBe(true);
+        expect(fs_1.default.existsSync((0, materializer_1.globalContextPath)())).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, 'AGENTS.md'))).toBe(true);
+        expect(orch.contextStatus(op)).toBe('injected');
+    });
+});

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 })),
         };
     }