agentic-workflow-manager 9.14.0 → 9.15.0

package/dist/tests/commands/hooks/resync.test.js

@@ -65,6 +65,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf8'));
         expect(settings.hooks.SubagentStart[0].hooks[0].command).toBe('awm model-policy hook-event --event start');
@@ -85,6 +86,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'not-installed' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/hooks/session-start'))).toBe(false);
     });
@@ -117,6 +119,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.lstatSync(skillDest).isSymbolicLink()).toBe(false);
         const content = fs_1.default.readFileSync(skillDest, 'utf-8');
@@ -135,6 +138,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(true);
         // Task 6: using-awm.md is materialized regardless of the scripts' install method —
@@ -151,6 +155,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'registry-missing' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
     });
@@ -166,6 +171,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'session-start'))).toBe(true);
         // detectInstallMethod fell back to copy since lstatSync threw
@@ -189,6 +195,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'registry-missing' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         // old script left intact — never leave user without hook
         expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
@@ -219,6 +226,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'not-installed' },
             { agent: 'codex', action: 'resynced' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.readFileSync(path_1.default.join(codexScriptsDir, 'session-start'), 'utf-8')).toContain('NEW CODEX');
     });

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

@@ -395,20 +395,22 @@ 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.
+    // Gap A (QA panel) — GLOBAL-scope Cursor skill delivery. Plan B installs
+    // Cursor skills as links under ~/.agents/skills (shared with Codex/
+    // OpenCode) plus native hooks.json entries (registry floor >= 4.9.0).
+    // Drives a real `awm init --agent cursor` through installBundle/
+    // applyInstallPlan (only syncCache stubbed) and asserts the link + hooks.
     // -----------------------------------------------------------------------
-    it('Gap A — real global-scope render: awm init --agent cursor renders a real .mdc into ~/.cursor/rules', async () => {
+    it('Gap A — real global-scope link: awm init --agent cursor links using-awm into ~/.agents/skills', async () => {
+        const { spawnSync } = require('child_process');
         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.
+        // A 'hooks' dir is what makes capabilityRoot('hooks') resolve to this content
+        // root — registryRoot for stepContextInjection / stepHook. Plan B also needs
+        // the three Cursor hook scripts and an exact v4.9.0+ tag for the registry floor.
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
+        for (const name of ['cursor-session-start', 'cursor-pre-compact', 'cursor-post-tool-use']) {
+            fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', name), '#!/usr/bin/env node\nconsole.log("{}")\n', { mode: 0o755 });
+        }
         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 });
@@ -420,6 +422,10 @@ describe('runInit', () => {
             name: 'dev-core', version: '1.0.0', description: 'Baseline', scope: 'baseline',
             dependsOn: [], skills: ['using-awm'], workflows: [], agents: [],
         }));
+        spawnSync('git', ['init', '-q', '-b', 'main'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'add', '.'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-qm', 'fixture'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['tag', 'v4.9.0'], { cwd: contentRoot, stdio: 'ignore' });
         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');
@@ -431,20 +437,15 @@ describe('runInit', () => {
                 // 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.
+                // on disk. Only syncCache is stubbed.
                 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.');
+            const linked = path_1.default.join(tmpHome, '.agents', 'skills', 'using-awm');
+            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'rules', 'using-awm.mdc'))).toBe(false);
+            expect(fs_1.default.lstatSync(linked).isSymbolicLink() || fs_1.default.existsSync(path_1.default.join(linked, 'SKILL.md'))).toBe(true);
+            expect(fs_1.default.readFileSync(path_1.default.join(linked, 'SKILL.md'), 'utf8')).toContain('MUST invoke skills per the tiered policy.');
+            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'hooks.json'))).toBe(true);
         }
         finally {
             fs_1.default.rmSync(projectCwd, { recursive: true, force: true });

package/dist/tests/commands/plan/index.test.js

@@ -309,6 +309,32 @@ describe('plan admit Commander wiring', () => {
             process.exitCode = undefined;
         }
     });
+    it.each([
+        ['a content registry', true, 'admitted'],
+        ['an ordinary project', false, 'blocked'],
+    ])('applies the R8 sensor opt-out exception only to %s', async (_name, isRegistry, expected) => {
+        const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-r8-')));
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        if (isRegistry)
+            fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({ minCliVersion: '1.0.0' }));
+        const sensors = jest.fn().mockResolvedValue({ overall: 'not_certified', sensors: [], mode: 'opt-out', reason: 'opt-out-declared', projectRoot: root, manifestPath: path_1.default.join(root, '.awm', 'sensors.json') });
+        const program = new commander_1.Command();
+        (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => valid, listRegistries: () => [], readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }), runSensors: sensors });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--execution-mode', 'interactivo', '--verify-sensors', '--json']);
+            const report = JSON.parse(String(output.mock.calls.at(-1)[0]));
+            expect(report).toMatchObject({ state: expected, sensors: 'not-certified' });
+            if (isRegistry)
+                expect(report.sensorEvidence).toBe('r8-registry-opt-out');
+            else
+                expect(report.diagnostics[0].code).toBe('ADMISSION_SENSORS_BLOCKED');
+        }
+        finally {
+            output.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
     it('derives desatendido from the canonical plan header; a native v1 plan needs no journal (opt-in durable custody)', async () => {
         const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-header-'));
         const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
@@ -462,7 +488,11 @@ describe('plan admit Commander wiring', () => {
             process.exitCode = undefined;
         }
     });
-    it.each([['cursor', 'global'], ['cursor', 'local'], ['copilot', 'local']])('does not prove absence for actual unowned rendered %s %s runtime contracts', async (target, scope) => {
+    // Cursor skills are link-installed under ~/.agents/skills (same as Codex); only
+    // content renderers still need this "rendered copy ≠ ownership" proof. Link
+    // unowned cases are covered by the runtime-unowned scenarios above.
+    it('does not prove absence for actual unowned rendered copilot local runtime contracts', async () => {
+        const target = 'copilot';
         const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rendered-admission-')));
         const oldHome = process.env.HOME;
         process.env.HOME = path_1.default.join(root, 'home');
@@ -474,7 +504,7 @@ describe('plan admit Commander wiring', () => {
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ minCliVersion: '1.0.0' }));
         fs_1.default.writeFileSync(path_1.default.join(root, 'source.md'), 'project source');
         const provider = (0, providers_1.providerFor)(target);
-        const directory = scope === 'global' ? provider.skill.global : path_1.default.resolve(root, provider.skill.local);
+        const directory = path_1.default.resolve(root, provider.skill.local);
         fs_1.default.mkdirSync(directory, { recursive: true });
         const installedFile = path_1.default.join(directory, (0, registry_1.renderedFilename)('using-awm', provider.skill.renderer));
         fs_1.default.writeFileSync(installedFile, (0, registry_1.renderArtifact)(provider.skill.renderer, skillSource));
@@ -514,6 +544,56 @@ describe('plan admit Commander wiring', () => {
             process.exitCode = undefined;
         }
     });
+    it.each([['cursor', 'global'], ['cursor', 'local']])('does not prove absence for actual unowned linked %s %s runtime contracts', async (target, scope) => {
+        const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-linked-admission-')));
+        const oldHome = process.env.HOME;
+        process.env.HOME = path_1.default.join(root, 'home');
+        const outputSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const registryRoot = path_1.default.join(root, 'registry');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ minCliVersion: '1.0.0' }));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'source.md'), 'project source');
+        const unowned = path_1.default.join(root, 'unowned', 'using-awm');
+        fs_1.default.mkdirSync(unowned, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(unowned, 'SKILL.md'), '---\nname: using-awm\ndescription: contract\n---\nRuntime contract.\n');
+        const provider = (0, providers_1.providerFor)(target);
+        const directory = scope === 'global' ? provider.skill.global : path_1.default.resolve(root, provider.skill.local);
+        fs_1.default.mkdirSync(directory, { recursive: true });
+        const artifact = path_1.default.join(directory, (0, registry_1.renderedFilename)('using-awm', provider.skill.renderer));
+        fs_1.default.symlinkSync(unowned, artifact, process.platform === 'win32' ? 'junction' : 'dir');
+        const sensors = jest.fn();
+        const program = new commander_1.Command();
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => ({ ...valid, manifest: { ...valid.manifest, sources: [{ id: 'source', path: 'source.md', locator: 'contract', fact: 'contract' }] } }),
+            listRegistries: () => [{ name: 'fixture', remote: 'https://example.invalid/fixture.git', contentRoot: registryRoot }],
+            readPreferences: () => ({ defaultAgent: target, enabledAgents: [target], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: async () => ({ checkedAt: 'x', compatibility: { status: 'not-checked' }, components: [{ component: 'cli', installed: '1.0.0', latest: '1.0.0', channel: 'stable', source: 'fixture', checkedAt: 'x', status: 'current', detail: 'ok', remedy: 'none' }] }),
+            runSensors: sensors,
+        });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', target, '--cwd', root, '--execution-mode', 'interactivo', '--require-current', '--verify-sensors', '--json']);
+            const output = JSON.parse(String(outputSpy.mock.calls.at(-1)[0]));
+            expect(output.diagnostics[0].code).toBe('ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED');
+            expect(output.state).toBe('blocked');
+            const reported = /^Runtime artifact (.+) has no unique physical registry owner/.exec(output.diagnostics[0].message);
+            expect(reported).not.toBeNull();
+            const reportedIdentity = fs_1.default.lstatSync(reported[1], { bigint: true });
+            const installedIdentity = fs_1.default.lstatSync(artifact, { bigint: true });
+            expect(reportedIdentity.isSymbolicLink() || reportedIdentity.isDirectory()).toBe(true);
+            expect(reportedIdentity.ino).not.toBe(0n);
+            expect([reportedIdentity.dev, reportedIdentity.ino]).toEqual([installedIdentity.dev, installedIdentity.ino]);
+            expect(sensors).not.toHaveBeenCalled();
+        }
+        finally {
+            if (oldHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = oldHome;
+            outputSpy.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
     it.each(['symlink', 'directory', 'oversized', 'duplicate-floor', 'unsafe-floor', 'stale-before-compatibility'])('keeps registry manifest %s noncertifying before sensors', async (scenario) => {
         const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-manifest-admission-')));
         const registryRoot = path_1.default.join(root, 'registry');

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

@@ -161,21 +161,30 @@ describe('runCommand — exit codes and output', () => {
     });
     itLinux('never lets a structured capture file grow beyond maxBuffer', async () => {
         const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-exec-cap-'));
-        const marker = path_1.default.join(dir, 'written');
-        const existing = new Set(fs_1.default.readdirSync(os_1.default.tmpdir()).filter(name => name.startsWith('awm-sensor-output-')));
+        // The overflow watcher kills the child and deletes the capture as soon as
+        // the cap is reached, so polling for the file races that cleanup. Capture
+        // files only grow, so their size at deletion is the largest they ever were.
+        const captureSizes = [];
+        const rmSync = fs_1.default.rmSync.bind(fs_1.default);
+        const removal = jest.spyOn(fs_1.default, 'rmSync').mockImplementation((target, options) => {
+            if (typeof target === 'string' && path_1.default.basename(target).startsWith('awm-sensor-output-')) {
+                captureSizes.push(fs_1.default.statSync(path_1.default.join(target, 'stdout')).size);
+            }
+            return rmSync(target, options);
+        });
         try {
-            const result = (0, exec_1.runStructuredCommand)({
+            const result = await (0, exec_1.runStructuredCommand)({
                 executable: 'node',
                 resolution: 'path',
-                args: ['-e', `const fs = require('fs'); try { fs.writeSync(1, Buffer.alloc(8192, 'x')); } catch {} fs.writeFileSync(${JSON.stringify(marker)}, 'written'); setTimeout(() => {}, 1000);`],
+                args: ['-e', `const fs = require('fs'); try { fs.writeSync(1, Buffer.alloc(8192, 'x')); } catch {} setTimeout(() => {}, 1000);`],
             }, { timeout: 5_000, cwd: dir, maxBuffer: 1_024 });
-            expect(await until(() => fs_1.default.existsSync(marker))).toBe(true);
-            const capture = fs_1.default.readdirSync(os_1.default.tmpdir()).find(name => name.startsWith('awm-sensor-output-') && !existing.has(name));
-            expect(capture).toBeDefined();
-            expect(fs_1.default.statSync(path_1.default.join(os_1.default.tmpdir(), capture, 'stdout')).size).toBeLessThanOrEqual(1_024);
-            await expect(result).resolves.toMatchObject({ overflowed: true });
+            expect(result).toMatchObject({ overflowed: true });
+            expect(captureSizes).toHaveLength(1);
+            expect(captureSizes[0]).toBeGreaterThan(0);
+            expect(captureSizes[0]).toBeLessThanOrEqual(1_024);
         }
         finally {
+            removal.mockRestore();
             fs_1.default.rmSync(dir, { recursive: true, force: true });
         }
     });

package/dist/tests/core/admission/index.test.js

@@ -178,6 +178,45 @@ describe('admitPlan', () => {
             expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
         });
     });
+    // R8: a content registry whose sensors are ALL deliberately disabled may close
+    // work; its release proof lives in CI. The local verdict stays not-certified —
+    // never reported as pass — and the exception is named in the evidence.
+    describe('the R8 registry opt-out closure exception', () => {
+        const optOut = { overall: 'not_certified', sensors: [], mode: 'opt-out', reason: 'opt-out-declared', projectRoot: '/r', manifestPath: '/r/.awm/sensors.json' };
+        const unattended = () => ({ ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } });
+        const base = () => ({ plan: valid, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], verifySensors: true, sensors: optOut, sensorClosurePolicy: 'r8-registry-opt-out' });
+        it('admits interactive work without reporting the opt-out as a pass', async () => {
+            const report = await (0, admission_1.admitPlan)(base());
+            expect(report).toMatchObject({ state: 'admitted', sensors: 'not-certified', sensorEvidence: 'r8-registry-opt-out' });
+        });
+        it('admits journal-less unattended work under the same exception', async () => {
+            const report = await (0, admission_1.admitPlan)({ ...base(), plan: unattended(), planPath: 'docs/plan.md', controllerAutonomy: 'approval-free' });
+            expect(report).toMatchObject({ state: 'admitted', executionMode: 'desatendido', journal: 'not-required', sensors: 'not-certified', sensorEvidence: 'r8-registry-opt-out' });
+        });
+        it('reports the preserved verdict when a later gate blocks', async () => {
+            const report = await (0, admission_1.admitPlan)({ ...base(), plan: unattended(), planPath: 'docs/plan.md' });
+            expect(report).toMatchObject({ state: 'blocked', sensors: 'not-certified', sensorEvidence: 'r8-registry-opt-out' });
+            expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
+        });
+        it.each([
+            ['no declared policy', { sensorClosurePolicy: undefined }],
+            ['a failing sensor', { sensors: { ...optOut, overall: 'fail', mode: 'project-sensors' } }],
+            ['an absent manifest', { sensors: { ...optOut, mode: 'missing', reason: 'manifest-absent' } }],
+            ['a native gate', { sensors: { ...optOut, mode: 'native-gate', reason: 'native-gate-declared' } }],
+            ['an unavailable sensor source', { sensors: { ...optOut, mode: 'source-unavailable' } }],
+            ['all-disabled legacy sensors', { sensors: { ...optOut, overall: 'skipped', mode: 'project-sensors' } }],
+        ])('keeps blocking with %s', async (_name, fields) => {
+            const report = await (0, admission_1.admitPlan)({ ...base(), ...fields });
+            expect(report.state).toBe('blocked');
+            expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_SENSORS_BLOCKED' });
+            expect(report.sensorEvidence).toBeUndefined();
+        });
+        it('accepts only the known sensor evidence values at the public sanitizer', () => {
+            const report = { state: 'admitted', planState: 'valid', journal: 'not-required', currentness: 'not-checked', sensors: 'not-certified', diagnostics: [] };
+            expect((0, admission_1.sanitizeAdmissionReport)({ ...report, sensorEvidence: 'r8-registry-opt-out' }).sensorEvidence).toBe('r8-registry-opt-out');
+            expect(() => (0, admission_1.sanitizeAdmissionReport)({ ...report, sensorEvidence: 'opt-out' })).toThrow('invalid report');
+        });
+    });
     it('admits unattended work only with an exact schema-2 plan binding', async () => {
         const unattended = { ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } };
         const journal = { ...(0, types_1.emptyState)('main'), schema: 2, planBinding: { path: 'docs/plan.md', digest: 'a'.repeat(64), schema: 'compact-slices/v1', executionMode: 'desatendido', boundAt: '2026-09-15T00:00:00.000Z' } };

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

@@ -284,12 +284,8 @@ 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)', () => {
+    it('materializes a Cursor skill as a link under .agents/skills via the real default applyInstallPlan (Plan B 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)({
@@ -300,15 +296,12 @@ describe('installBundle', () => {
             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.');
+        const linked = path_1.default.join(projectRoot, '.agents/skills/s-base');
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.cursor/rules/s-base.mdc'))).toBe(false);
+        expect(fs_1.default.lstatSync(linked).isSymbolicLink() || fs_1.default.existsSync(path_1.default.join(linked, 'SKILL.md'))).toBe(true);
+        expect(fs_1.default.readFileSync(path_1.default.join(linked, 'SKILL.md'), 'utf8')).toContain('Do the base thing.');
         expect(result.transactionId).toBeTruthy();
-        expect(result.modifiedFiles).toContain(mdcPath);
+        expect(result.modifiedFiles).toContain(linked);
     });
     it('materializes a skill as rendered Copilot .instructions.md via the real default applyInstallPlan (Task 4.3 e2e)', () => {
         const { content, projectRoot, bundles } = makeFixture();
@@ -338,7 +331,8 @@ describe('installBundle', () => {
             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(fs_1.default.existsSync(path_1.default.join(projectRoot, '.agents/skills/s-base'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.cursor/rules/s-base.mdc'))).toBe(false);
         expect(cursorResult.recordedExtension).toBe('base');
         const copilotResult = (0, bundle_install_1.addBundle)({
             bundleName: 'base', bundles, agents: ['copilot'],

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

@@ -162,14 +162,8 @@ describe('CodexAgentsStrategy', () => {
         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');
+    it('Cursor inject writes PROJECT_GUIDANCE only (using-awm lives in the hook — Plan B R4/R10)', () => {
+        const project = path_1.default.join(tmpWork, 'cursor-guidance-only');
         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.';
@@ -186,15 +180,40 @@ describe('CodexAgentsStrategy', () => {
             projectRoot: project,
         };
         expect(strategy.inject(input, provider)).toBe('injected');
-        expect(strategy.injectProject(project, provider, 'cursor')).toBe('injected'); // carrier only
+        expect(strategy.injectProject(project, provider, 'cursor')).toBe('injected'); // awm.mdc carrier
         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(written).not.toContain('MUST invoke skills');
+        expect(written).not.toContain('# AWM');
         expect(strategy.status(input, provider)).toBe('injected');
-        // Idempotent: a second full pass (context re-inject, then constitution/carrier) changes nothing.
+        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');
         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('Copilot inject still writes full using-awm plus PROJECT_GUIDANCE (sole carrier)', () => {
+        const project = path_1.default.join(tmpWork, 'copilot-full-context');
+        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 = copilotProvider();
+        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: '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('MUST invoke skills per policy');
+        expect(written).toContain('Read and obey `CONSTITUTION.md` before work');
+        expect(strategy.status(input, provider)).toBe('injected');
     });
     it('implements global status and remove while preserving user bytes', () => {
         const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');