agentic-workflow-manager 3.11.0 → 3.13.0

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

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/commands/add.test.ts
+//
+// Real, unstubbed `awm add <bundle>` end-to-end for the Task 4.3 renderers:
+// runAddBundleCore → (real) addBundle → installBundle → planInstall
+// (install-planner.ts) → applyInstallPlan (install-transaction.ts) →
+// renderCursorMdc/renderCopilotInstructions — proving the full pipeline
+// wires together at the actual CLI command entrypoint, not just at the
+// bundle-install.ts layer (see tests/core/bundle-install.test.ts for the
+// lower-level equivalent). Per CLAUDE.md: isolated HOME/AWM_HOME tmpdirs,
+// never the real ~/.awm.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const add_1 = require("../../src/commands/add");
+const bundles_1 = require("../../src/core/bundles");
+let tmpHome;
+let originalHome;
+let originalAwmHome;
+beforeEach(() => {
+    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-add-e2e-home-'));
+    originalHome = process.env.HOME;
+    originalAwmHome = process.env.AWM_HOME;
+    process.env.HOME = tmpHome;
+    process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+});
+afterEach(() => {
+    fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    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;
+});
+/** A single-bundle content registry: one skill with real description+body. */
+function makeContentFixture() {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-add-e2e-registry-'));
+    fs_1.default.mkdirSync(path_1.default.join(tmp, 'bundles', 'demo'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(tmp, 'skills', 'demo-skill'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(tmp, 'skills', 'demo-skill', 'SKILL.md'), '---\nname: demo-skill\ndescription: A demo skill for add.test.ts e2e\n---\n\nFollow the demo skill body.\n');
+    fs_1.default.writeFileSync(path_1.default.join(tmp, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [{ name: 'demo', source: './bundles/demo', version: '1.0.0', scope: 'project' }],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(tmp, 'bundles', 'demo', 'bundle.json'), JSON.stringify({
+        name: 'demo', version: '1.0.0', description: 'Demo', scope: 'project', dependsOn: [],
+        skills: ['demo-skill'], workflows: [], agents: [],
+    }));
+    return tmp;
+}
+function prefsFor(agent) {
+    return { defaultAgent: agent, enabledAgents: [agent], installMethod: 'symlink', defaultScope: 'local' };
+}
+/** findProjectRoot (core/profile.ts) needs a recognizable project marker
+ *  (.git/, package.json, or .awm/profile.json) — a bare tmpdir isn't one. */
+function makeProjectRoot() {
+    const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-add-e2e-project-'));
+    fs_1.default.writeFileSync(path_1.default.join(projectRoot, 'package.json'), JSON.stringify({ name: 'fixture' }));
+    return projectRoot;
+}
+it('awm add demo materializes a real Cursor .mdc file end-to-end', () => {
+    const content = makeContentFixture();
+    const projectRoot = makeProjectRoot();
+    const bundles = (0, bundles_1.discoverBundles)(content);
+    const outcome = (0, add_1.runAddBundleCore)({ name: 'demo', agent: 'cursor', cwd: projectRoot }, prefsFor('cursor'), bundles);
+    expect(outcome.code).toBe(0);
+    const mdcPath = path_1.default.join(projectRoot, '.cursor/rules/demo-skill.mdc');
+    expect(fs_1.default.existsSync(mdcPath)).toBe(true);
+    const rendered = fs_1.default.readFileSync(mdcPath, 'utf8');
+    expect(rendered).toContain('description: A demo skill for add.test.ts e2e');
+    expect(rendered).toContain('alwaysApply: false');
+    expect(rendered).toContain('Follow the demo skill body.');
+    fs_1.default.rmSync(content, { recursive: true, force: true });
+    fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+});
+it('awm add demo materializes a real Copilot .instructions.md file end-to-end', () => {
+    const content = makeContentFixture();
+    const projectRoot = makeProjectRoot();
+    const bundles = (0, bundles_1.discoverBundles)(content);
+    const outcome = (0, add_1.runAddBundleCore)({ name: 'demo', agent: 'copilot', cwd: projectRoot }, prefsFor('copilot'), bundles);
+    expect(outcome.code).toBe(0);
+    const instructionsPath = path_1.default.join(projectRoot, '.github/instructions/demo-skill.instructions.md');
+    expect(fs_1.default.existsSync(instructionsPath)).toBe(true);
+    const rendered = fs_1.default.readFileSync(instructionsPath, 'utf8');
+    expect(rendered).toContain('applyTo: "**"');
+    expect(rendered).toContain('Follow the demo skill body.');
+    fs_1.default.rmSync(content, { recursive: true, force: true });
+    fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+});

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

@@ -58,6 +58,22 @@ describe('renderReport', () => {
         expect(out).toContain('→ skill: project-constitution');
     });
 });
+describe('renderProviderReport — capability tier (Task 4.4)', () => {
+    it('shows the tier next to each provider label', () => {
+        const report = {
+            overall: 'healthy',
+            providers: [
+                { id: 'claude-code', label: 'Claude Code', tier: 'hooks-native', checks: [] },
+                { id: 'cursor', label: 'Cursor', tier: 'agents-md-managed', checks: [] },
+                { id: 'antigravity', label: 'Antigravity', tier: 'context-only', checks: [] },
+            ],
+        };
+        const out = (0, doctor_1.renderProviderReport)(report);
+        expect(out).toContain('Provider: Claude Code (hooks-native)');
+        expect(out).toContain('Provider: Cursor (agents-md-managed)');
+        expect(out).toContain('Provider: Antigravity (context-only)');
+    });
+});
 describe('runDoctor', () => {
     let tmpHome;
     let tmpWork;
@@ -120,6 +136,7 @@ describe('runDoctor', () => {
             .toEqual(['claude-code', 'opencode', 'codex']); // verifies R12
         expect(report.providers.find((provider) => provider.id === 'codex'))
             .toMatchObject({
+            tier: 'hooks-native', // Task 4.4
             checks: expect.arrayContaining([
                 expect.objectContaining({ id: 'binary.version' }),
                 expect.objectContaining({ id: 'skills.global' }),
@@ -129,6 +146,14 @@ describe('runDoctor', () => {
         }); // verifies R2, R7, R8, R18
         expect(code).toBe(1);
     });
+    it('includes tier for every provider in JSON output (Task 4.4)', () => {
+        writePrefs(prefsWith(['claude-code', 'opencode', 'codex']));
+        const code = (0, doctor_1.runDoctor)({ cwd: tmpWork, json: true });
+        const report = JSON.parse(stdout());
+        expect(report.providers.map((provider) => provider.tier))
+            .toEqual(['hooks-native', 'config-managed', 'hooks-native']);
+        expect(code).toBe(1);
+    });
     it('reports a clear, specific error for an invalid --agent value, not a generic "internal error"', () => {
         const errSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
         try {

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/commands/preflight/preflight.test.js

@@ -312,6 +312,81 @@ describe('preflight', () => {
             expect(check(report, 'host').detail).toContain('gitlab detected');
         });
     });
+    describe('sensors-baseline check (advisory — never changes the exit code)', () => {
+        it('nudges toward `awm sensors baseline` when sensors are configured but no baseline exists', () => {
+            // The team-rollout gap this addresses: a legacy repo adopts AWM, sensors get
+            // configured, and the ratchet mechanism exists to snapshot pre-existing debt —
+            // but nothing tells the operator it's there until they hit a wall of red
+            // findings and go looking for it.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
+            expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
+            expect(report.status).toBe('ready');
+        });
+        it('reports the no-advisory-needed state when a baseline already exists, without nudging', () => {
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), JSON.stringify({ lint: [] }));
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('baseline present');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+            expect(report.status).toBe('ready');
+        });
+        it('is omitted entirely when there is no manifest at all — nothing to baseline without sensors', () => {
+            const dir = make();
+            const report = (0, checks_1.preflight)(dir);
+            expect(report.checks.find(c => c.id === 'sensors-baseline')).toBeUndefined();
+            expect(report.status).toBe('not_configured');
+        });
+        it('does not nudge on a deliberate opt-out (every sensor disabled) — nothing to baseline', () => {
+            // Regression: the trigger condition originally checked only manifestExists, so a
+            // repo that deliberately opted out (checkManifest's own documented pattern: every
+            // sensor `enabled: false`) still got told to run `awm sensors baseline` — nothing
+            // to baseline when there's nothing enabled to have findings in the first place.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .', enabled: false } } },
+            });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+        });
+        it('does not nudge on an unparseable manifest — nothing to baseline', () => {
+            const dir = make({ manifest: '{not valid json' });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+        });
+        it('still nudges when the baseline path exists but is not a readable file (e.g. a stray directory)', () => {
+            // Regression: checking presence via `fs.existsSync` alone would have reported
+            // "baseline present" here, reassuring the operator that debt is suppressed —
+            // but the real gate (`readBaseline`, used by `partition()`) treats an unreadable
+            // baseline path as "no baseline, nothing suppressed". The advisory must track
+            // what the runtime actually does, not just whether something exists at the path.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            fs_1.default.mkdirSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), { recursive: true });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
+            expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
+        });
+    });
     it('tells the operator not to hand a broken harness to an unattended run', () => {
         const out = (0, preflight_1.formatReport)({
             status: 'not_configured',
@@ -320,4 +395,24 @@ describe('preflight', () => {
         expect(out).toContain('unattended');
         expect(out).toContain('awm sensors init');
     });
+    it('pads the id column to the widest id actually present, not a hardcoded width', () => {
+        // Regression: a literal `.padEnd(9)` silently misaligned once `sensors-baseline`
+        // (16 chars) was added as a check id — every detail column shifted left of where
+        // shorter ids' details landed. The width must be derived from the report itself.
+        // Marker prefixes (@@) pin exactly where each detail column starts, independent
+        // of the detail text's own content.
+        const out = (0, preflight_1.formatReport)({
+            status: 'ready',
+            checks: [
+                { id: 'host', ok: true, detail: '@@marker' },
+                { id: 'sensors-baseline', ok: true, detail: '@@marker' },
+            ],
+        });
+        const lines = out.split('\n').filter(l => l.includes('@@marker'));
+        expect(lines).toHaveLength(2);
+        expect(lines[0].indexOf('@@marker')).toBe(lines[1].indexOf('@@marker'));
+        // And the column is genuinely sized to the longest id (16, 'sensors-baseline'),
+        // not the old hardcoded 9 — the shorter id's row must carry visible padding.
+        expect(lines[0]).toMatch(/host {12,}@@marker/);
+    });
 });

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