agentic-workflow-manager 9.7.1 → 9.9.0

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

@@ -8,20 +8,24 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
+const validate_1 = require("../../../src/core/plan/validate");
 const plan_1 = require("../../../src/commands/plan");
+const init_1 = require("../../../src/commands/watch/init");
+const providers_1 = require("../../../src/providers");
+const registry_1 = require("../../../src/core/renderers/registry");
 const stdoutWrite = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
-const valid = {
-    state: 'valid', schema: 'compact-slices/v1', manifest: {
-        schema: 'compact-slices/v1', planId: 'r4-plan', requirements: ['R4-VAL-1', 'R4-VAL-4'],
-        sources: [], commands: [], slices: [], closureCommands: [],
-    },
-};
+const repositoryRoot = path_1.default.resolve(__dirname, '../../../..');
+const approved = (0, validate_1.validatePlanFile)('docs/plans/2026-09-14-compact-only-bootstrap-plan.md', repositoryRoot);
+if (approved.state !== 'valid')
+    throw new Error(`tracked bootstrap plan must validate before command tests: ${approved.state}`);
+const valid = approved;
 const invalid = {
     state: 'invalid', diagnostics: [{ code: 'PLAN_MARKERS', message: 'compact markers must occur once in order' }],
 };
 const unsupported = {
     state: 'unsupported', schema: 'compact-slices/v2', diagnostics: [{ code: 'PLAN_UNSUPPORTED_SCHEMA', message: 'unsupported compact plan schema; update the CLI' }],
 };
+const migration = { state: 'migration-required', reason: 'unmarked-plan' };
 function commandFor(report, calls = []) {
     const program = new commander_1.Command();
     program.exitOverride();
@@ -44,23 +48,83 @@ describe('plan validate Commander wiring', () => {
         stdoutWrite.mockRestore();
         process.exitCode = previousExitCode;
     });
+    it('returns v1 not-required before reading personal policy or capability state', async () => {
+        const policy = jest.fn();
+        const capabilities = jest.fn();
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => valid, readEffectivePolicy: policy, readCapabilities: capabilities });
+        await program.parseAsync(['node', 'awm', 'plan', 'resolve', 'plans/r4.md', '--provider', 'codex', '--runtime-kind', 'native', '--runtime-version', '1.0.0', '--account-scope-digest', 'a'.repeat(64), '--role', 'controller', '--json']);
+        expect(JSON.parse(String(stdoutWrite.mock.calls[0][0]))).toEqual({ state: 'not-required', reason: 'v1-without-opt-in' });
+        expect(policy).not.toHaveBeenCalled();
+        expect(capabilities).not.toHaveBeenCalled();
+    });
     it('emits deterministic human output for a valid compact plan', async () => {
         await commandFor(valid).parseAsync(['node', 'awm', 'plan', 'validate', 'plans/r4.md']);
-        expect(String(stdoutWrite.mock.calls[0][0])).toBe('Plan validation: valid "plans/r4.md" (compact-slices/v1; 0 slices; 2 requirements; complete ownership)\n');
+        expect(String(stdoutWrite.mock.calls[0][0])).toBe('Plan validation: valid "plans/r4.md" (compact-slices/v1; 1 slices; 5 requirements; complete ownership)\n');
         expect(process.exitCode).toBe(0);
     });
     it('emits one stable JSON object without an update banner', async () => {
         await commandFor(valid).parseAsync(['node', 'awm', 'plan', 'validate', 'plans/r4.md', '--json']);
         expect(JSON.parse(String(stdoutWrite.mock.calls[0][0]))).toEqual({
-            state: 'valid', path: 'plans/r4.md', schema: 'compact-slices/v1', planId: 'r4-plan',
-            requirements: 2, sources: 0, commands: 0, slices: 0, completeOwnership: true,
+            state: 'valid', path: 'plans/r4.md', schema: 'compact-slices/v1', planId: 'issue-126-compact-only-bootstrap',
+            planDigest: valid.planDigest, requirements: 5, sources: 6, commands: 7, slices: 1, completeOwnership: true,
         });
         expect(String(stdoutWrite.mock.calls[0][0])).not.toContain('update');
     });
-    it('keeps a legacy plan on the existing full-quality path with exit 0', async () => {
-        await commandFor({ state: 'legacy' }).parseAsync(['node', 'awm', 'plan', 'validate', 'legacy.md']);
-        expect(String(stdoutWrite.mock.calls[0][0])).toBe('Plan validation: legacy "legacy.md" — existing full-quality path applies; compact optimization was not requested.\n');
-        expect(process.exitCode).toBe(0);
+    it('emits deterministic migration-only human guidance and exit 2', async () => {
+        await commandFor(migration).parseAsync(['node', 'awm', 'plan', 'validate', 'legacy.md']);
+        expect(String(stdoutWrite.mock.calls[0][0])).toBe('Plan validation: migration-required "legacy.md" (unmarked-plan)\nMigrate this plan to compact-slices/v1 before execution.\n');
+        expect(String(stdoutWrite.mock.calls[0][0])).not.toMatch(/full-quality|alternate|legacy path/i);
+        expect(process.exitCode).toBe(2);
+    });
+    it('writes one stable migration JSON object before assigning exit 2', async () => {
+        const observedExitCodes = [];
+        stdoutWrite.mockImplementation(() => { observedExitCodes.push(process.exitCode); return true; });
+        await commandFor(migration).parseAsync(['node', 'awm', 'plan', 'validate', 'legacy.md', '--json']);
+        const output = String(stdoutWrite.mock.calls[0][0]);
+        expect(output).toBe('{"state":"migration-required","path":"legacy.md","reason":"unmarked-plan"}\n');
+        expect(JSON.parse(output)).toEqual({ state: 'migration-required', path: 'legacy.md', reason: 'unmarked-plan' });
+        expect(output).not.toMatch(/full-quality|alternate|legacy path/i);
+        expect(observedExitCodes).toEqual([undefined]);
+        expect(process.exitCode).toBe(2);
+    });
+    it.each(['human', 'json'])('rejects a malformed injected migration report in %s mode before output', async (mode) => {
+        const malformed = { state: 'migration-required' };
+        const args = ['node', 'awm', 'plan', 'validate', 'unmarked.md', ...(mode === 'json' ? ['--json'] : [])];
+        await expect(commandFor(malformed).parseAsync(args)).rejects.toThrow('plan validator returned an invalid migration reason');
+        expect(stdoutWrite).not.toHaveBeenCalled();
+        expect(process.exitCode).toBeUndefined();
+    });
+    it('enforces migration-only output and exit 2 through the compiled CLI without mutating an unmarked plan', () => {
+        const repoRoot = path_1.default.resolve(__dirname, '../../../..');
+        const compiled = path_1.default.join(repoRoot, 'cli', 'dist', 'src', 'index.js');
+        const fixtureRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-plan-unmarked-e2e-'));
+        const plan = path_1.default.join(fixtureRoot, 'unmarked.md');
+        const isolatedHome = path_1.default.join(fixtureRoot, 'home');
+        fs_1.default.mkdirSync(isolatedHome);
+        fs_1.default.writeFileSync(plan, '# Unmarked plan\n');
+        const before = fs_1.default.readFileSync(plan);
+        const environment = { ...process.env, HOME: isolatedHome, AWM_HOME: path_1.default.join(isolatedHome, '.awm') };
+        try {
+            expect(fs_1.default.existsSync(compiled)).toBe(true);
+            const human = (0, child_process_1.spawnSync)(process.execPath, [compiled, 'plan', 'validate', 'unmarked.md', '--cwd', fixtureRoot], {
+                cwd: repoRoot, env: environment, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const json = (0, child_process_1.spawnSync)(process.execPath, [compiled, 'plan', 'validate', 'unmarked.md', '--cwd', fixtureRoot, '--json'], {
+                cwd: repoRoot, env: environment, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            expect(human.status).toBe(2);
+            expect(human.stdout).toBe('Plan validation: migration-required "unmarked.md" (unmarked-plan)\nMigrate this plan to compact-slices/v1 before execution.\n');
+            expect(json.status).toBe(2);
+            expect(JSON.parse(json.stdout)).toEqual({ state: 'migration-required', path: 'unmarked.md', reason: 'unmarked-plan' });
+            expect(human.stdout + json.stdout).not.toMatch(/full-quality|alternate|legacy path/i);
+            expect(fs_1.default.readFileSync(plan).equals(before)).toBe(true);
+        }
+        finally {
+            fs_1.default.rmSync(fixtureRoot, { recursive: true, force: true });
+        }
     });
     it.each([
         ['invalid', invalid],
@@ -139,16 +203,620 @@ describe('plan validate Commander wiring', () => {
         }
     });
 });
+describe('plan admit Commander wiring', () => {
+    it('does not read v2 routing facts after currentness blocks', async () => {
+        const policy = jest.fn();
+        const capabilities = jest.fn();
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => ({ ...valid, schema: 'compact-slices/v2', manifest: { ...valid.manifest, schema: 'compact-slices/v2', slices: valid.manifest.slices.map(slice => ({ ...slice, implementerProfile: 'mechanical' })) } }), readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }), readEffectivePolicy: policy, readCapabilities: capabilities, listRegistries: () => [], checkCurrentness: async () => ({ checkedAt: 'x', compatibility: { status: 'not-checked' }, components: [{ component: 'cli', installed: '1', latest: '2', channel: 'stable', source: 'x', checkedAt: 'x', status: 'stale', detail: 'x', remedy: 'x' }] }) });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', repositoryRoot, '--require-current', '--runtime-kind', 'native', '--runtime-version', '1.0.0', '--account-scope-digest', 'a'.repeat(64), '--json']);
+            expect(policy).not.toHaveBeenCalled();
+            expect(capabilities).not.toHaveBeenCalled();
+        }
+        finally {
+            output.mockRestore();
+            process.exitCode = undefined;
+        }
+    });
+    it.each([
+        ['invalid plan', invalid, 'codex', ['codex']],
+        ['invalid provider', valid, 'not-a-provider', ['codex']],
+        ['disabled provider', valid, 'codex', ['cursor']],
+    ])('does not read routing facts for %s even with complete runtime flags', async (_name, report, provider, enabledAgents) => {
+        const policy = jest.fn();
+        const capabilities = jest.fn();
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => report, readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: [...enabledAgents], installMethod: 'symlink', defaultScope: 'local' }), readEffectivePolicy: policy, readCapabilities: capabilities });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', provider, '--cwd', repositoryRoot, '--runtime-kind', 'native', '--runtime-version', '1.0.0', '--account-scope-digest', 'a'.repeat(64), '--json']);
+            expect(policy).not.toHaveBeenCalled();
+            expect(capabilities).not.toHaveBeenCalled();
+        }
+        finally {
+            output.mockRestore();
+            process.exitCode = undefined;
+        }
+    });
+    it('derives desatendido from the canonical plan header and requires a journal without a flag', 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);
+        try {
+            (0, child_process_1.spawnSync)('git', ['init', '-q', '-b', 'main'], { cwd: root });
+            fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '**Modo de ejecución:** desatendido\n');
+            (0, child_process_1.spawnSync)('git', ['config', 'user.email', 'test@example.invalid'], { cwd: root });
+            (0, child_process_1.spawnSync)('git', ['config', 'user.name', 'Test'], { cwd: root });
+            (0, child_process_1.spawnSync)('git', ['add', 'plan.md'], { cwd: root });
+            (0, child_process_1.spawnSync)('git', ['commit', '-qm', 'fixture'], { cwd: root });
+            const program = new commander_1.Command();
+            program.exitOverride();
+            program.configureOutput({ writeErr: () => undefined });
+            (0, plan_1.registerPlanCommand)(program, {
+                validatePlanFile: () => valid,
+                readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            });
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--json']);
+            expect(JSON.parse(String(output.mock.calls[0][0]))).toMatchObject({ state: 'blocked', executionMode: 'desatendido', journal: expect.stringMatching(/missing|corrupt/) });
+        }
+        finally {
+            output.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
+    it('uses executionMode from the validated snapshot when the plan file changes before admission', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-snapshot-mode-'));
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const admittedSnapshot = { ...valid, executionMode: 'desatendido' };
+        const admit = jest.fn().mockResolvedValue({ state: 'admitted', planState: 'valid', journal: 'current', currentness: 'not-checked', sensors: 'not-required', diagnostics: [] });
+        try {
+            // This is deliberately the opposite header: a second read here would
+            // silently downgrade the authenticated unattended snapshot.
+            fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '**Modo de ejecución:** interactivo\n');
+            const program = new commander_1.Command();
+            program.exitOverride();
+            program.configureOutput({ writeErr: () => undefined });
+            (0, plan_1.registerPlanCommand)(program, {
+                validatePlanFile: () => admittedSnapshot,
+                admitPlan: admit,
+                readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            });
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--json']);
+            expect(admit).toHaveBeenCalledWith(expect.objectContaining({ executionMode: 'desatendido' }));
+        }
+        finally {
+            output.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
+    it('uses an explicit validated execution-mode override over the canonical header', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-header-override-'));
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const admit = jest.fn().mockResolvedValue({ state: 'admitted', planState: 'valid', journal: 'not-required', currentness: 'not-checked', sensors: 'not-required', diagnostics: [] });
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '**Modo de ejecución:** desatendido\n');
+            const program = new commander_1.Command();
+            program.exitOverride();
+            program.configureOutput({ writeErr: () => undefined });
+            (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => valid, admitPlan: admit, readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }) });
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--execution-mode', 'interactivo', '--json']);
+            expect(admit).toHaveBeenCalledWith(expect.objectContaining({ executionMode: 'interactivo' }));
+        }
+        finally {
+            output.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
+    it('passes the current branch schema-2 journal and normalized plan path to unattended admission', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-journal-'));
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const admit = jest.fn().mockResolvedValue({ state: 'admitted', planState: 'valid', journal: 'current', currentness: 'not-checked', sensors: 'not-required', diagnostics: [] });
+        try {
+            (0, child_process_1.spawnSync)('git', ['init', '-q', '-b', 'main'], { cwd: root });
+            (0, init_1.initWatch)(root, 'main', { path: 'plans/current.md', report: valid });
+            const program = new commander_1.Command();
+            program.exitOverride();
+            program.configureOutput({ writeErr: () => undefined });
+            (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => valid, admitPlan: admit, readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }) });
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plans/current.md', '--provider', 'codex', '--cwd', root, '--execution-mode', 'desatendido', '--json']);
+            expect(admit).toHaveBeenCalledWith(expect.objectContaining({ executionMode: 'desatendido', planPath: 'plans/current.md', journalCorrupt: false, journalState: expect.objectContaining({ schema: 2, planBinding: expect.objectContaining({ digest: valid.planDigest }) }) }));
+        }
+        finally {
+            output.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
+    it.each(['compatible', 'newer-cli-required', 'invalid-manifest', 'unconsumed', 'runtime-supplier', 'runtime-unowned', 'runtime-dangling', 'runtime-directory'])('checks the consumed registry CLI floor before sensors (%s)', async (scenario) => {
+        const outputSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const oldHome = process.env.HOME;
+        const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pair-admission-')));
+        const registryRoot = path_1.default.join(root, 'registry');
+        fs_1.default.mkdirSync(registryRoot);
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'source.md'), 'contract');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'source.md'), 'project source');
+        if (scenario.startsWith('runtime-')) {
+            process.env.HOME = path_1.default.join(root, 'home');
+            const installed = path_1.default.join(process.env.HOME, '.agents', 'skills');
+            const source = path_1.default.join(scenario === 'runtime-unowned' ? root : registryRoot, 'skills', 'using-awm');
+            fs_1.default.mkdirSync(installed, { recursive: true });
+            fs_1.default.mkdirSync(source, { recursive: true });
+            if (scenario === 'runtime-directory')
+                fs_1.default.mkdirSync(path_1.default.join(source, 'SKILL.md'));
+            else if (scenario !== 'runtime-dangling')
+                fs_1.default.writeFileSync(path_1.default.join(source, 'SKILL.md'), 'runtime contract');
+            fs_1.default.symlinkSync(source, path_1.default.join(installed, 'using-awm'), process.platform === 'win32' ? 'junction' : 'dir');
+        }
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), scenario === 'invalid-manifest' ? '{bad' : JSON.stringify({ minCliVersion: scenario === 'compatible' ? '1.0.0' : '999.0.0' }));
+        const report = { ...valid, manifest: { ...valid.manifest, sources: [{ id: 'source', path: scenario === 'unconsumed' || scenario.startsWith('runtime-') ? 'source.md' : 'registry/source.md', locator: 'contract', fact: 'contract' }] } };
+        const sensors = jest.fn().mockResolvedValue({ overall: 'pass', sensors: [] });
+        const program = new commander_1.Command();
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => report,
+            listRegistries: () => [{ name: 'fixture', remote: 'https://example.invalid/fixture.git', contentRoot: registryRoot }],
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: async () => ({ checkedAt: 'x', compatibility: { status: 'not-checked' }, components: ['cli', 'registry:fixture'].map(component => ({ component, 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', 'codex', '--cwd', root, '--execution-mode', 'interactivo', '--require-current', '--verify-sensors', '--json']);
+            const output = JSON.parse(String(outputSpy.mock.calls.at(-1)[0]));
+            if (scenario === 'compatible' || scenario === 'unconsumed') {
+                expect(output.state).toBe('admitted');
+                expect(sensors).toHaveBeenCalledTimes(1);
+            }
+            else {
+                expect(output.state).toBe('blocked');
+                const unknownSupplier = ['runtime-unowned', 'runtime-dangling', 'runtime-directory'].includes(scenario);
+                expect(output.diagnostics[0].code).toBe(unknownSupplier ? 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED' : scenario === 'invalid-manifest' ? 'ADMISSION_REGISTRY_COMPATIBILITY_UNVERIFIABLE' : 'ADMISSION_REGISTRY_CLI_INCOMPATIBLE');
+                if (!unknownSupplier)
+                    expect(output.diagnostics[0].message).toContain('registry:fixture');
+                expect(sensors).not.toHaveBeenCalled();
+                expect(process.exitCode).toBe(2);
+            }
+        }
+        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([['cursor', 'global'], ['cursor', 'local'], ['copilot', 'local']])('does not prove absence for actual unowned rendered %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-rendered-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');
+        const skillSource = path_1.default.join(registryRoot, 'skills', 'using-awm');
+        fs_1.default.mkdirSync(skillSource, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillSource, 'SKILL.md'), '---\nname: using-awm\ndescription: contract\n---\nRuntime contract.\n');
+        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);
+        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));
+        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');
+            // Global diagnostics may retain the declared path while local ones
+            // use a physical root. Windows 8.3/long names are equivalent: prove
+            // that the reported path names this exact file, not its spelling.
+            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(installedFile, { bigint: true });
+            expect(reportedIdentity.isFile()).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');
+        fs_1.default.mkdirSync(registryRoot);
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'source.md'), 'registry source');
+        const manifest = path_1.default.join(registryRoot, 'awm-registry.json');
+        if (scenario === 'symlink') {
+            fs_1.default.writeFileSync(path_1.default.join(root, 'outside-manifest'), '{}');
+            fs_1.default.symlinkSync(path_1.default.join(root, 'outside-manifest'), manifest, 'file');
+        }
+        else if (scenario === 'directory')
+            fs_1.default.mkdirSync(manifest);
+        else
+            fs_1.default.writeFileSync(manifest, scenario === 'oversized' ? ' '.repeat(256 * 1024 + 1)
+                : scenario === 'duplicate-floor' ? '{"minCliVersion":"999.0.0","minCliVersion":"1.0.0"}'
+                    : scenario === 'unsafe-floor' ? '{"minCliVersion":"' + '9'.repeat(1024) + '.0.0"}' : '{bad json');
+        const outputSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const sensors = jest.fn();
+        const program = new commander_1.Command();
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => ({ ...valid, manifest: { ...valid.manifest, sources: [{ id: 'source', path: 'registry/source.md', locator: 'contract', fact: 'contract' }] } }),
+            listRegistries: () => [{ name: 'fixture', remote: 'https://example.invalid/fixture.git', contentRoot: registryRoot }],
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: async () => ({ checkedAt: 'x', compatibility: { status: 'not-checked' }, components: ['cli', 'registry:fixture'].map(component => ({ component, installed: '1.0.0', latest: '1.0.0', channel: 'stable', source: 'fixture', checkedAt: 'x', status: scenario === 'stale-before-compatibility' ? 'stale' : 'current', detail: 'observed', remedy: 'none' })) }),
+            runSensors: sensors,
+        });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--execution-mode', 'interactivo', '--require-current', '--verify-sensors', '--json']);
+            const output = JSON.parse(String(outputSpy.mock.calls.at(-1)[0]));
+            expect(output.state).toBe('blocked');
+            expect(output.diagnostics[0].code).toBe(scenario === 'stale-before-compatibility' ? 'ADMISSION_CURRENTNESS_BLOCKED' : 'ADMISSION_REGISTRY_COMPATIBILITY_UNVERIFIABLE');
+            expect(sensors).not.toHaveBeenCalled();
+        }
+        finally {
+            outputSpy.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
+    it.each(['owner-currentness', 'inventory-currentness', 'owner-sensors', 'floor-sensors', 'registry-identity-currentness', 'body-currentness'])('rechecks actual runtime contract %s after awaits before admitted', async (scenario) => {
+        const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-supplier-drift-')));
+        const oldHome = process.env.HOME;
+        process.env.HOME = path_1.default.join(root, 'home');
+        const registryRoot = path_1.default.join(root, 'registry');
+        const owned = path_1.default.join(registryRoot, 'skills', 'using-awm');
+        const unowned = path_1.default.join(root, 'unowned', 'using-awm');
+        const replacementRoot = path_1.default.join(root, 'replacement-registry');
+        const replacementOwned = path_1.default.join(replacementRoot, 'skills', 'using-awm');
+        for (const directory of [owned, unowned, replacementOwned]) {
+            fs_1.default.mkdirSync(directory, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(directory, 'SKILL.md'), 'contract');
+        }
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(replacementRoot, 'awm-registry.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'source.md'), 'project source');
+        const installed = (0, providers_1.providerFor)('codex').skill.global;
+        fs_1.default.mkdirSync(installed, { recursive: true });
+        const artifact = path_1.default.join(installed, 'using-awm');
+        fs_1.default.symlinkSync(owned, artifact, process.platform === 'win32' ? 'junction' : 'dir');
+        const outputSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let inventoryChanged = false;
+        let registryChanged = false;
+        const replaceOwner = () => { fs_1.default.unlinkSync(artifact); fs_1.default.symlinkSync(unowned, artifact, process.platform === 'win32' ? 'junction' : 'dir'); };
+        const sensors = jest.fn().mockImplementation(async () => {
+            if (scenario === 'owner-sensors')
+                replaceOwner();
+            if (scenario === 'floor-sensors')
+                fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), '{"minCliVersion":"999.0.0"}');
+            return { overall: 'pass', sensors: [] };
+        });
+        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: inventoryChanged ? 'replacement' : 'fixture', remote: registryChanged ? 'https://replacement.invalid/fixture.git' : 'https://example.invalid/fixture.git', contentRoot: registryChanged ? replacementRoot : registryRoot }],
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: async () => {
+                if (scenario === 'owner-currentness')
+                    replaceOwner();
+                if (scenario === 'inventory-currentness')
+                    inventoryChanged = true;
+                if (scenario === 'registry-identity-currentness') {
+                    registryChanged = true;
+                    fs_1.default.unlinkSync(artifact);
+                    fs_1.default.symlinkSync(replacementOwned, artifact, process.platform === 'win32' ? 'junction' : 'dir');
+                }
+                if (scenario === 'body-currentness')
+                    fs_1.default.writeFileSync(path_1.default.join(owned, 'SKILL.md'), 'changed native runtime contract');
+                return { checkedAt: 'x', compatibility: { status: 'not-checked' }, components: ['cli', 'registry:fixture'].map(component => ({ component, 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', 'codex', '--cwd', root, '--execution-mode', 'interactivo', '--require-current', '--verify-sensors', '--json']);
+            const output = JSON.parse(String(outputSpy.mock.calls.at(-1)[0]));
+            expect(output.state).toBe('blocked');
+            expect(output.diagnostics[0].code).toBe(scenario === 'floor-sensors' ? 'ADMISSION_REGISTRY_CLI_INCOMPATIBLE' : 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED');
+            expect(sensors).toHaveBeenCalledTimes(scenario.endsWith('sensors') ? 1 : 0);
+        }
+        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('keeps an unreadable inventory root actionable instead of silently proving it unconsumed', async () => {
+        const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-root-admission-')));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'source.md'), 'project source');
+        const outputSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const sensors = jest.fn();
+        const currentness = 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: 'unavailable-supplier', remote: 'https://example.invalid/fixture.git', contentRoot: path_1.default.join(root, 'missing-registry') }],
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: currentness, runSensors: sensors,
+        });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--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.diagnostics[0].message).toContain('unavailable-supplier');
+            expect(currentness).not.toHaveBeenCalled();
+            expect(sensors).not.toHaveBeenCalled();
+        }
+        finally {
+            outputSpy.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
+    it('does not run sensors after currentness blocks', async () => {
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const sensors = jest.fn();
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => valid, listRegistries: () => [],
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: async () => ({ checkedAt: 'x', compatibility: { status: 'not-checked' }, components: [{ component: 'cli', installed: '1.0.0', latest: '2.0.0', channel: 'stable', source: 'npm', checkedAt: 'x', status: 'stale', detail: 'stale', remedy: 'update' }] }),
+            runSensors: sensors,
+        });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', repositoryRoot, '--require-current', '--verify-sensors', '--json']);
+            expect(sensors).not.toHaveBeenCalled();
+            expect(JSON.parse(String(output.mock.calls[0][0]))).toMatchObject({ state: 'blocked', currentness: 'stale', sensors: 'not-required' });
+        }
+        finally {
+            output.mockRestore();
+            process.exitCode = undefined;
+        }
+    });
+    it('rejects a forged admission report before output or exit status', async () => {
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => valid,
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            admitPlan: async () => ({ state: 'admitted', planState: 'valid', journal: 'not-required', currentness: 'current', sensors: 'pass', diagnostics: 'forged' }),
+        });
+        try {
+            await expect(program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', repositoryRoot, '--json'])).rejects.toThrow('admission returned an invalid report');
+            expect(output).not.toHaveBeenCalled();
+            expect(process.exitCode).toBeUndefined();
+        }
+        finally {
+            output.mockRestore();
+            process.exitCode = undefined;
+        }
+    });
+    it('does not prove registry irrelevance through a source symlink that escapes cwd', async () => {
+        const fixtureRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-provenance-'));
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-outside-'));
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const currentness = jest.fn();
+        const admit = jest.fn().mockResolvedValue({ state: 'blocked', planState: 'valid', journal: 'not-required', currentness: 'unverifiable', sensors: 'not-required', diagnostics: [] });
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(outside, 'contract.md'), 'outside');
+            fs_1.default.symlinkSync(outside, path_1.default.join(fixtureRoot, 'linked'), process.platform === 'win32' ? 'junction' : 'dir');
+            const escaped = { ...valid, manifest: { ...valid.manifest, sources: [{ id: 'SRC', path: 'linked/contract.md', locator: 'x', fact: 'x' }] } };
+            const program = new commander_1.Command();
+            program.exitOverride();
+            program.configureOutput({ writeErr: () => undefined });
+            (0, plan_1.registerPlanCommand)(program, {
+                validatePlanFile: () => escaped, admitPlan: admit,
+                readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+                listRegistries: () => [], checkCurrentness: currentness,
+            });
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', fixtureRoot, '--require-current', '--json']);
+            expect(currentness).not.toHaveBeenCalled();
+            expect(admit).toHaveBeenCalledWith(expect.objectContaining({ provenance: 'unknown', consumedRegistryComponents: [] }));
+        }
+        finally {
+            output.mockRestore();
+            fs_1.default.rmSync(fixtureRoot, { recursive: true, force: true });
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
+    it('bounds and terminal-sanitizes adversarial admission diagnostics in JSON', async () => {
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => valid,
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            admitPlan: async () => ({ state: 'blocked', planState: 'valid', journal: 'not-required', currentness: 'not-checked', sensors: 'not-required', diagnostics: [{ code: `X\u001b${'c'.repeat(5000)}`, message: `Y\u001b${'m'.repeat(5000)}` }] }),
+        });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plans/r4.md', '--provider', 'codex', '--cwd', 'fixture-root', '--json']);
+            const json = String(output.mock.calls[0][0]);
+            expect(json.trimEnd()).not.toMatch(/[\u0000-\u001f\u007f-\u009f]/);
+            expect(JSON.parse(json).diagnostics[0]).toEqual({ code: expect.stringMatching(/^X\\u001b/), message: expect.stringMatching(/^Y\\u001b/) });
+            expect(JSON.parse(json).diagnostics[0].message.length).toBeLessThanOrEqual(4096);
+        }
+        finally {
+            output.mockRestore();
+            process.exitCode = undefined;
+        }
+    });
+    it('uses the bounded admission surface and preserves JSON output', async () => {
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        process.exitCode = undefined;
+        const admit = jest.fn()
+            .mockResolvedValue({
+            state: 'blocked', planState: 'valid', planDigest: valid.planDigest, provider: 'codex', executionMode: 'interactivo',
+            journal: 'not-required', currentness: 'not-checked', sensors: 'not-required', diagnostics: [{ code: 'ADMISSION_CURRENTNESS_REQUIRED', message: 'required' }],
+        });
+        const sensorRun = jest.fn().mockResolvedValue({ overall: 'pass', sensors: [] });
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, {
+            validatePlanFile: () => valid, admitPlan: admit,
+            readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
+            checkCurrentness: async () => ({ checkedAt: '2026-01-01T00:00:00.000Z', components: [], compatibility: { status: 'not-checked' } }),
+            runSensors: sensorRun,
+            listRegistries: () => [],
+        });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plans/r4.md', '--provider', 'codex', '--cwd', repositoryRoot, '--verify-sensors', '--json']);
+            expect(sensorRun).toHaveBeenCalledWith({ cwd: repositoryRoot, all: true, readOnly: true });
+            expect(admit).toHaveBeenLastCalledWith(expect.objectContaining({ provider: 'codex', cwd: repositoryRoot, requireCurrent: false, verifySensors: true, plan: valid, provenance: 'proven' }));
+            expect(JSON.parse(String(output.mock.calls[0][0]))).toMatchObject({ state: 'blocked', provider: 'codex' });
+            expect(process.exitCode).toBe(2);
+        }
+        finally {
+            output.mockRestore();
+            process.exitCode = undefined;
+        }
+    });
+});
 describe('plan validation public boundaries', () => {
+    it.each([
+        ['empty red commands', { slices: [{ ...valid.manifest.slices[0], redCommands: [] }] }],
+        ['bogus review evidence', { slices: [{ ...valid.manifest.slices[0], reviewEvidence: ['specification', 'bogus'] }] }],
+        ['bogus risk', { slices: [{ ...valid.manifest.slices[0], risk: 'unbounded' }] }],
+        ['dangling closure command', { closureCommands: ['CMD-MISSING'] }],
+    ])('rejects a forged valid report with %s before output or exit 0', (_name, changes) => {
+        const forged = { ...valid, manifest: { ...valid.manifest, ...changes } };
+        expect(() => (0, plan_1.formatReport)(forged, 'plan.md')).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.exitCodeFor)(forged)).toThrow('plan validator returned an invalid valid report');
+    });
+    it('rejects a structurally plausible forged or deserialized valid report', () => {
+        const deserialized = JSON.parse(JSON.stringify(valid));
+        const forged = { ...valid };
+        expect(() => (0, plan_1.formatReport)(deserialized, 'plan.md')).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.exitCodeFor)(deserialized)).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.exitCodeFor)(forged)).toThrow('plan validator returned an invalid valid report');
+    });
+    it.each([
+        'docs/plans/2026-08-26-r4a-compact-plan-cli-plan.md',
+        'docs/plans/2026-08-27-sensor-portability-publication-a-plan.md',
+        'docs/plans/2026-09-07-retire-onsignal.md',
+        'docs/plans/2026-09-14-compact-only-bootstrap-plan.md',
+    ])('accepts a validator-produced tracked v1 report at both public boundaries: %s', (file) => {
+        const report = (0, validate_1.validatePlanFile)(file, repositoryRoot);
+        expect(report.state).toBe('valid');
+        expect((0, plan_1.exitCodeFor)(report)).toBe(0);
+        expect((0, plan_1.formatReport)(report, file)).toContain('complete ownership');
+    });
     it.each([
         ['valid', valid, 0],
-        ['legacy', { state: 'legacy' }, 0],
+        ['migration-required', migration, 2],
         ['invalid', { state: 'invalid', diagnostics: [] }, 2],
         ['unsupported', { state: 'unsupported', schema: 'compact-slices/v2', diagnostics: [] }, 2],
     ])('maps %s reports to exit %i', (_state, report, code) => {
         expect((0, plan_1.exitCodeFor)(report)).toBe(code);
     });
+    it('fails loudly rather than returning exit 0 for an injected valid state without a manifest', () => {
+        const malformed = { state: 'valid' };
+        expect(() => (0, plan_1.exitCodeFor)(malformed)).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.formatReport)(malformed, 'plan.md')).toThrow('plan validator returned an invalid valid report');
+    });
+    it('rejects a valid report missing the required closureCommands collection', () => {
+        const malformed = { ...valid, manifest: { ...valid.manifest, closureCommands: undefined } };
+        expect(() => (0, plan_1.exitCodeFor)(malformed)).toThrow('plan validator returned an invalid valid report');
+    });
+    it.each(['requirements', 'sources', 'commands', 'slices', 'closureCommands'])('rejects a null %s entry before claiming complete ownership or exit 0', (collection) => {
+        const malformed = {
+            ...valid, manifest: { ...valid.manifest, [collection]: [null] },
+        };
+        expect(() => (0, plan_1.formatReport)(malformed, 'plan.md')).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.exitCodeFor)(malformed)).toThrow('plan validator returned an invalid valid report');
+    });
+    it.each(['human', 'json'])('rejects a null manifest slice before %s output or exit 0', async (mode) => {
+        const malformed = {
+            ...valid, manifest: { ...valid.manifest, slices: [null] },
+        };
+        const args = ['node', 'awm', 'plan', 'validate', 'plan.md', ...(mode === 'json' ? ['--json'] : [])];
+        await expect(commandFor(malformed).parseAsync(args)).rejects.toThrow('plan validator returned an invalid valid report');
+        expect(stdoutWrite).not.toHaveBeenCalled();
+        expect(process.exitCode).toBeUndefined();
+    });
+    it('rejects an unowned requirement before claiming complete ownership or exit 0', () => {
+        const malformed = { ...valid, manifest: { ...valid.manifest, requirements: [...valid.manifest.requirements, 'R4-VAL-5'] } };
+        expect(() => (0, plan_1.formatReport)(malformed, 'plan.md')).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.exitCodeFor)(malformed)).toThrow('plan validator returned an invalid valid report');
+    });
+    it('rejects a requirement owned by two slices', () => {
+        const malformed = {
+            ...valid, manifest: { ...valid.manifest, slices: [...valid.manifest.slices, {
+                        ...valid.manifest.slices[0], id: 'S2', requirements: [valid.manifest.requirements[0]],
+                    }] },
+        };
+        expect(() => (0, plan_1.formatReport)(malformed, 'plan.md')).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.exitCodeFor)(malformed)).toThrow('plan validator returned an invalid valid report');
+    });
+    it.each(['requirements', 'sources', 'commands', 'slices', 'closureCommands'])('rejects an empty %s collection in an injected valid report', (collection) => {
+        const malformed = {
+            ...valid, manifest: { ...valid.manifest, [collection]: [] },
+        };
+        expect(() => (0, plan_1.formatReport)(malformed, 'plan.md')).toThrow('plan validator returned an invalid valid report');
+        expect(() => (0, plan_1.exitCodeFor)(malformed)).toThrow('plan validator returned an invalid valid report');
+    });
+    it('fails loudly for a migration state without its required reason at the public exit boundary', () => {
+        const malformed = { state: 'migration-required' };
+        expect(() => (0, plan_1.exitCodeFor)(malformed)).toThrow('plan validator returned an invalid migration reason');
+    });
     it('fails loudly for an invalid validator dependency', () => {
         expect(() => (0, plan_1.registerPlanCommand)(new commander_1.Command(), {})).toThrow('validatePlanFile must be a function');
     });
 });
+describe('plan migration-facts command', () => {
+    it('emits deterministic JSON through the injected read-only collector', async () => {
+        const write = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => valid, collectMigrationFacts: () => ({ state: 'planning-required', issueLinks: ['https://github.com/Kodria/agentic-workflow/issues/126'], tasks: [], diagnostics: ['missing'], facts: [] }) });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'migration-facts', 'old.md', '--issue', 'https://github.com/Kodria/agentic-workflow/issues/126', '--json']);
+            expect(JSON.parse(String(write.mock.calls.at(-1)?.[0]))).toMatchObject({ state: 'planning-required', diagnostics: ['missing'] });
+        }
+        finally {
+            write.mockRestore();
+        }
+    });
+    it('rejects missing issue input before invoking collection', async () => {
+        const collectMigrationFacts = jest.fn();
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => valid, collectMigrationFacts });
+        await expect(program.parseAsync(['node', 'awm', 'plan', 'migration-facts', 'old.md'])).rejects.toThrow();
+        expect(collectMigrationFacts).not.toHaveBeenCalled();
+    });
+});