agentic-workflow-manager 3.10.0 → 3.12.0

package/dist/tests/commands/sensors/run.test.js

@@ -86,6 +86,79 @@ describe('runSensors', () => {
         expect(sec.status).toBe('skipped');
         expect(sec.skipReason).toBe('disabled');
     });
+    it('dispatches by the formatter field, not the sensor name — ruff on a `lint` sensor', async () => {
+        // The whole point of the `formatter` field: a `lint` sensor is eslint for
+        // js-ts but ruff for python. Old name-based dispatch (lint -> eslint parser)
+        // would choke on ruff's flat JSON array (no `.messages` — TypeError) instead
+        // of parsing it. Real captured `ruff --output-format json` shape.
+        const pythonManifest = {
+            pack: 'python',
+            sensors: {
+                lint: { cmd: 'ruff check . --output-format json', fast: true, formatter: 'ruff' },
+            },
+        };
+        fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify(pythonManifest));
+        const ruffJson = JSON.stringify([{
+                code: 'F401',
+                filename: path.join(tmpDir, 'bad.py'),
+                location: { row: 1, column: 8 },
+                message: '`os` imported but unused',
+            }]);
+        mockRunCommand.mockResolvedValueOnce(exited(1, ruffJson));
+        const { runSensors } = load();
+        const result = await runSensors({ fast: true, cwd: tmpDir });
+        const lint = result.sensors.find((s) => s.name === 'lint');
+        expect(lint.status).toBe('fail');
+        expect(lint.errors[0].rule).toBe('F401');
+        expect(lint.errors[0].message).toMatch('SENSOR[lint]');
+        expect(lint.errors[0].message).toMatch('imported but unused');
+    });
+    it('falls back to name-based dispatch when formatter is absent (pre-existing manifest)', async () => {
+        // A manifest written before the `formatter` field existed must keep working
+        // exactly as before: `lint` -> eslint parser, no `formatter` key anywhere.
+        mockRunCommand
+            .mockResolvedValueOnce(exited(1, 'src/a.ts(1,1): error TS0001: Bad type.'))
+            .mockResolvedValueOnce(exited(1, JSON.stringify([{ filePath: '/x/a.js', messages: [{ ruleId: 'no-unused-vars', severity: 2, message: 'unused', line: 1, column: 1 }] }])));
+        const { runSensors } = load();
+        const result = await runSensors({ fast: true, cwd: tmpDir });
+        const lint = result.sensors.find((s) => s.name === 'lint');
+        expect(lint.status).toBe('fail');
+        expect(lint.errors[0].rule).toBe('no-unused-vars');
+    });
+    it('degrades to the generic formatter (never a wrong-shape misparse) for an unrecognized formatter value', async () => {
+        // Regression for Finding 5: `formatter: 'bandit'` is present but not one of the
+        // 8 known values. The OLD behavior fell through to name-based dispatch — sensor
+        // name 'security' -> parseSemgrepOutput — which would silently misparse
+        // bandit's differently-shaped `results` entries (no `path`/`start`/`check_id`
+        // keys) into garbage findings (`file: undefined, line: 0`). The fix must use
+        // parseGenericOutput instead: an honest raw-wrap, never a wrong-shape guess.
+        const banditManifest = {
+            pack: 'python',
+            sensors: {
+                security: { cmd: 'bandit -r . -f json', fast: false, formatter: 'bandit' },
+            },
+        };
+        fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify(banditManifest));
+        // Real bandit JSON shape (fields semgrep's parser does not know how to read).
+        const banditJson = JSON.stringify({
+            results: [
+                { filename: 'app.py', line_number: 12, test_id: 'B105', issue_text: 'hardcoded password' },
+            ],
+        });
+        mockRunCommand.mockResolvedValueOnce(exited(1, banditJson));
+        const { runSensors } = load();
+        const result = await runSensors({ all: true, cwd: tmpDir });
+        const sec = result.sensors.find((s) => s.name === 'security');
+        expect(sec.status).toBe('fail');
+        expect(sec.errors).toHaveLength(1);
+        // Never the semgrep-misparse shape (file: undefined, line: 0, rule: undefined).
+        expect(sec.errors[0].file).toBeUndefined();
+        expect(sec.errors[0].line).toBeUndefined();
+        expect(sec.errors[0].rule).toBeUndefined();
+        // The honest generic raw-wrap: the raw JSON, verbatim, inside one message.
+        expect(sec.errors[0].message).toMatch('SENSOR[raw]');
+        expect(sec.errors[0].message).toContain('B105');
+    });
     const tcError = () => exited(1, 'src/a.ts(1,1): error TS0001: Bad type.');
     it('baseline suppresses accepted findings — sensor passes on no NEW findings', async () => {
         const { runSensors } = load();
@@ -160,6 +233,24 @@ describe('runSensors — missing tool is a fail, not a skip', () => {
         expect(out.overall).toBe('fail');
     });
 });
+describe('runSensors — sensors: null in a hand-edited manifest', () => {
+    // Regression for Finding 3: `checkManifest` (preflight) already guards
+    // `manifest.sensors ?? {}` — runSensors' `Object.entries(activeManifest.sensors)`
+    // needs the same guard, or a corrupted/hand-edited `.awm/sensors.json` with
+    // `"sensors": null` crashes `Object.entries(null)`, taking down the whole run.
+    it('degrades gracefully instead of throwing when sensors is null', async () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-null-sensors-'));
+        fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), JSON.stringify({ pack: 'python', sensors: null }));
+        try {
+            const result = await (0, run_1.runSensors)({ cwd: dir, all: true });
+            expect(result.sensors).toEqual([]);
+        }
+        finally {
+            fs_1.default.rmSync(dir, { recursive: true });
+        }
+    });
+});
 describe('runSensors — not_certified + auto-discovery', () => {
     let tmpDir;
     beforeEach(() => {

package/dist/tests/commands/sensors/status.test.js

@@ -109,6 +109,35 @@ describe('computeSensorStatus', () => {
             expect(result.checks.security.ok).toBe(true);
         });
     });
+    it('is DEGRADED (never HEALTHY) when the manifest has zero sensor entries', () => {
+        // `Object.values({}).every(...)` is vacuously true — guard against reading an
+        // empty manifest (the honest floor when the registry had no pack.json for the
+        // detected stack) as a clean run that found nothing wrong.
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'python',
+            sensors: {},
+        }));
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('DEGRADED');
+        expect(result.pack).toBe('python');
+    });
+    it('degrades gracefully (never throws) when sensors is null in a hand-edited manifest', () => {
+        // Regression for Finding 3: `checkManifest` (preflight) already guards
+        // `manifest.sensors ?? {}` — computeSensorStatus needs the same guard, or a
+        // corrupted/hand-edited manifest with `"sensors": null` crashes
+        // `Object.entries(null)`.
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'python',
+            sensors: null,
+        }));
+        expect(() => (0, status_1.computeSensorStatus)(tmpDir)).not.toThrow();
+        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('DEGRADED');
+        expect(result.pack).toBe('python');
+        expect(result.checks).toEqual({});
+    });
     it('marks disabled sensors as ok', () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({

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