agentic-workflow-manager 9.11.12 → 9.12.0

package/dist/tests/commands/job/routing-file.test.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const job_1 = require("../../../src/commands/job");
+describe('bounded routing input', () => {
+    it('rejects a file that grows between metadata check and read', () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-routing-input-'));
+        const file = path_1.default.join(dir, 'observation.json');
+        try {
+            fs_1.default.writeFileSync(file, JSON.stringify({ parentThreadId: 'a'.repeat(300 * 1024) }));
+            const original = fs_1.default.lstatSync;
+            const stat = jest.spyOn(fs_1.default, 'lstatSync').mockImplementation(((target, ...args) => {
+                const actual = original(target, ...args);
+                return String(target) === file ? Object.assign(Object.create(Object.getPrototypeOf(actual)), actual, { size: 1 }) : actual;
+            }));
+            try {
+                expect(() => (0, job_1.readBoundedJson)(file)).toThrow(/bound|256|size|regular|large/i);
+            }
+            finally {
+                stat.mockRestore();
+            }
+        }
+        finally {
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/commands/job/routing-report-cli.test.js

@@ -19,7 +19,7 @@ function gitInit(repo) {
     (0, child_process_1.execFileSync)('git', ['add', '.'], { cwd: repo });
     (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', 'commit', '-qm', 'fixture'], { cwd: repo });
 }
-test('`job routing-report --json` emits only aggregate routing evidence', async () => {
+test('`job routing-report --json` exposes selections but not native child identities or envelopes', async () => {
     const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-routing-report-'));
     try {
         gitInit(repo);
@@ -40,9 +40,10 @@ test('`job routing-report --json` emits only aggregate routing evidence', async
         await program.parseAsync(['node', 'awm', 'job', 'routing-report', '--json']);
         const rendered = String(out.mock.calls[0][0]);
         const report = JSON.parse(rendered);
-        expect(report).toMatchObject({ schema: 'routing-report/v1', attempts: 1, plannedByRole: { implementer: 1 }, actualByRole: { implementer: 1 }, byState: { active: 1 } });
+        expect(report).toMatchObject({ schema: 'routing-report/v1', attempts: 1, plannedByRole: { implementer: 1 }, actualByRole: { implementer: 1 }, byState: { active: 1 },
+            selections: [{ configured: privateSelection, accepted: 'unknown', backendModel: 'unknown' }] });
         expect(rendered).not.toContain('native-private');
-        expect(rendered).not.toContain('model-private');
+        expect(rendered).not.toContain('obligation');
         cwd.mockRestore();
         out.mockRestore();
     }

package/dist/tests/commands/model-policy/claude-hook-flow.test.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 store_1 = require("../../../src/core/model-policy/store");
+const canonical_1 = require("../../../src/core/model-policy/canonical");
+const machine_key_1 = require("../../../src/core/model-policy/machine-key");
+const event_store_1 = require("../../../src/core/model-policy/event-store");
+describe('Claude hook to event receipt integration', () => {
+    it('captures a real-format hook pair and assistant trace without paid inference', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-hook-flow-'));
+        const previous = { home: process.env.HOME, awm: process.env.AWM_HOME, config: process.env.CLAUDE_CONFIG_DIR };
+        const awmHome = path_1.default.join(root, 'awm');
+        const project = path_1.default.join(root, 'project');
+        const configDir = path_1.default.join(root, 'claude');
+        const bin = path_1.default.join(root, 'bin');
+        fs_1.default.mkdirSync(awmHome);
+        fs_1.default.mkdirSync(project);
+        fs_1.default.mkdirSync(configDir);
+        fs_1.default.mkdirSync(bin);
+        process.env.HOME = root;
+        process.env.AWM_HOME = awmHome;
+        process.env.CLAUDE_CONFIG_DIR = configDir;
+        try {
+            (0, machine_key_1.ensureMachineKey)(awmHome);
+            const selected = { selector: { kind: 'model', id: 'claude-sonnet-4-6' }, effort: { kind: 'runtime-default' } };
+            const content = { schema: 'model-policy/v1', mappings: [{ target: 'claude-code', runtimeKind: 'native',
+                        profiles: { mechanical: selected, integration: selected, judgment: selected }, fullCapability: selected,
+                        degradation: { allowMissingModelOverride: false, allowMissingEffortOverride: false, allowMissingObservedIdentity: false } }],
+                implementationBudget: { maxAttempts: 3, escalation: ['mechanical', 'integration', 'judgment'], judgmentEfforts: ['medium', 'high'] } };
+            fs_1.default.writeFileSync(path_1.default.join(project, 'candidate.json'), JSON.stringify(content));
+            (0, store_1.approvePolicy)({ file: 'candidate.json', scope: 'project', cwd: project, expectedDigest: (0, canonical_1.canonicalPolicyDigest)(content) });
+            const executable = path_1.default.join(bin, process.platform === 'win32' ? 'claude.exe' : 'claude');
+            const authResponse = { loggedIn: true, authMethod: 'claude.ai', apiProvider: 'anthropic', email: 'test@example.invalid', orgId: 'org-test' };
+            let preload;
+            if (process.platform === 'win32') {
+                // A Unix shebang cannot be launched by CreateProcess. Use a real
+                // .exe and intercept only its auth-status invocation in Node.
+                fs_1.default.copyFileSync(process.execPath, executable);
+                preload = path_1.default.join(root, 'claude-preload.cjs');
+                fs_1.default.writeFileSync(preload, `if (require('path').basename(process.execPath).toLowerCase() === 'claude.exe' && require('path').basename(process.argv[1] || '') === 'auth') { process.stdout.write(${JSON.stringify(JSON.stringify(authResponse))}); process.exit(0); }\n`);
+            }
+            else {
+                fs_1.default.writeFileSync(executable, `#!${process.execPath}\nif (process.argv[2] === '--version') process.stdout.write('2.1.263\\n');\nelse if (process.argv[2] === 'auth') process.stdout.write(${JSON.stringify(JSON.stringify(authResponse))});\n`, { mode: 0o755 });
+            }
+            const timestamp = new Date().toISOString();
+            const transcript = path_1.default.join(configDir, 'projects', 'p', 's', 'subagents', 'agent-agent-1.jsonl');
+            fs_1.default.mkdirSync(path_1.default.dirname(transcript), { recursive: true });
+            fs_1.default.writeFileSync(transcript, `${JSON.stringify({ type: 'assistant', timestamp, message: { model: 'claude-sonnet-4-6', content: [] } })}\n`);
+            fs_1.default.mkdirSync(path_1.default.join(configDir, 'agents'));
+            fs_1.default.writeFileSync(path_1.default.join(configDir, 'agents', 'awm-integration.md'), '---\nname: awm-integration\ndescription: AWM integration agent\nmodel: claude-sonnet-4-6\n---\nPerform integration work.\n');
+            const start = { hook_event_name: 'SubagentStart', session_id: 'session-1', agent_id: 'agent-1', agent_type: 'awm-integration' };
+            const stop = { ...start, hook_event_name: 'SubagentStop', agent_transcript_path: transcript, stop_hook_active: false };
+            const cli = path_1.default.resolve(__dirname, '../../../dist/src/index.js');
+            const env = { ...process.env, PATH: `${bin}${path_1.default.delimiter}${process.env.PATH ?? ''}` };
+            if (preload)
+                env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --require=${JSON.stringify(preload)}`;
+            const authProbe = (0, child_process_1.spawnSync)(executable, ['auth', 'status'], { env, encoding: 'utf8' });
+            expect(authProbe.status).toBe(0);
+            expect(JSON.parse(authProbe.stdout)).toMatchObject(authResponse);
+            const versionProbe = (0, child_process_1.spawnSync)(executable, ['--version'], { env, encoding: 'utf8' });
+            expect(versionProbe.status).toBe(0);
+            expect(versionProbe.stdout).toMatch(/\d+\.\d+\.\d+/);
+            const first = (0, child_process_1.spawnSync)(process.execPath, [cli, 'model-policy', 'hook-event', '--event', 'start', '--cwd', project], { cwd: project, env, input: JSON.stringify(start), encoding: 'utf8' });
+            expect(first.status).toBe(0);
+            expect(first.stdout).toBe('');
+            const second = (0, child_process_1.spawnSync)(process.execPath, [cli, 'model-policy', 'hook-event', '--event', 'stop', '--cwd', project], { cwd: project, env, input: JSON.stringify(stop), encoding: 'utf8' });
+            expect(second.status).toBe(0);
+            expect(second.stdout).toBe('');
+            expect(second.stderr).toBe('');
+            const files = fs_1.default.readdirSync(path_1.default.join(awmHome, 'routing-capabilities-v2', 'claude-code'));
+            expect(files).toEqual(['native.json']);
+            const raw = fs_1.default.readFileSync(path_1.default.join(awmHome, 'routing-capabilities-v2', 'claude-code', 'native.json'), 'utf8');
+            expect(raw).not.toContain('test@example.invalid');
+            const persisted = JSON.parse(raw);
+            expect((0, event_store_1.readStoredEventReceipt)(persisted.receipt.runtime)).toMatchObject({ state: 'present', receipt: { claims: [expect.objectContaining({ selection: selected, nativeAgentType: 'awm-integration', actualModel: expect.objectContaining({ id: 'claude-sonnet-4-6' }), tokenUsage: 'unknown' })] } });
+            const generic = { ...start, agent_id: 'other-agent', agent_type: 'general-purpose' };
+            const ignored = (0, child_process_1.spawnSync)(process.execPath, [cli, 'model-policy', 'hook-event', '--event', 'start', '--cwd', project, '--json'], { cwd: project, env, input: JSON.stringify(generic), encoding: 'utf8' });
+            expect(ignored.status).toBe(0);
+            expect(JSON.parse(ignored.stdout)).toMatchObject({ state: 'ignored' });
+            expect(fs_1.default.readFileSync(path_1.default.join(awmHome, 'routing-capabilities-v2', 'claude-code', 'native.json'), 'utf8')).toBe(raw);
+        }
+        finally {
+            if (previous.home === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = previous.home;
+            if (previous.awm === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previous.awm;
+            if (previous.config === undefined)
+                delete process.env.CLAUDE_CONFIG_DIR;
+            else
+                process.env.CLAUDE_CONFIG_DIR = previous.config;
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/commands/model-policy/index.test.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const model_policy_1 = require("../../../src/commands/model-policy");
@@ -114,4 +147,150 @@ describe('model-policy command', () => {
         await expect(program.parseAsync(['node', 'awm', 'model-policy', 'capabilities', 'approve', '--file', 'receipt.json', '--expected-digest', 'a'.repeat(64), '--replace-digest', ''])).rejects.toThrow(/requires a non-empty value/);
         expect(approveCapabilities).not.toHaveBeenCalled();
     });
+    it('discovers the Codex catalog explicitly without approving capabilities', async () => {
+        const queryCodexModelCatalog = jest.fn(async () => ({ provenance: 'native-catalog', selections: [], nativeDispatchVerified: false, actualModelVerified: false }));
+        const approveCapabilities = jest.fn();
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { queryCodexModelCatalog, approveCapabilities: approveCapabilities });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'discover', '--provider', 'codex', '--json']);
+        expect(queryCodexModelCatalog).toHaveBeenCalledTimes(1);
+        expect(JSON.parse(String(out.mock.calls[0][0]))).toMatchObject({ state: 'catalog-only', nativeDispatchVerified: false, actualModelVerified: false });
+        expect(approveCapabilities).not.toHaveBeenCalled();
+    });
+    it('reports missing machine selections from the approved Codex policy without certifying dispatch', async () => {
+        const available = { selector: { kind: 'model', id: 'gpt-6-sol' }, effort: { kind: 'explicit', value: 'high' } };
+        const missing = { selector: { kind: 'model', id: 'gpt-6-luna' }, effort: { kind: 'explicit', value: 'low' } };
+        const queryCodexModelCatalog = jest.fn(async () => ({ provenance: 'native-catalog', selections: [available], nativeDispatchVerified: false, actualModelVerified: false }));
+        const readEffectivePolicy = jest.fn(() => ({ state: 'approved', policy: { content: { mappings: [{ target: 'codex', runtimeKind: 'native', profiles: { mechanical: missing, integration: available, judgment: available }, fullCapability: available }] } } }));
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { queryCodexModelCatalog, readEffectivePolicy: readEffectivePolicy });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'discover', '--provider', 'codex', '--cwd', 'fixture-root', '--json']);
+        expect(readEffectivePolicy).toHaveBeenCalledWith('fixture-root');
+        expect(JSON.parse(String(out.mock.calls[0][0]))).toMatchObject({ state: 'catalog-only', policyCoverage: { state: 'missing', missing: [missing] }, nativeDispatchVerified: false, actualModelVerified: false });
+        expect(process.exitCode).toBe(2);
+    });
+    it('reports catalog coverage but still refuses to claim native dispatch or backend identity', async () => {
+        const selection = { selector: { kind: 'model', id: 'gpt-6-sol' }, effort: { kind: 'explicit', value: 'high' } };
+        const queryCodexModelCatalog = jest.fn(async () => ({ provenance: 'native-catalog', selections: [selection], nativeDispatchVerified: false, actualModelVerified: false }));
+        const readEffectivePolicy = jest.fn(() => ({ state: 'approved', policy: { content: { mappings: [{ target: 'codex', runtimeKind: 'native', profiles: { mechanical: selection, integration: selection, judgment: selection }, fullCapability: selection }] } } }));
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { queryCodexModelCatalog, readEffectivePolicy: readEffectivePolicy });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'discover', '--provider', 'codex', '--json']);
+        expect(JSON.parse(String(out.mock.calls[0][0]))).toMatchObject({ state: 'catalog-only', policyCoverage: { state: 'complete', missing: [] }, nativeDispatchVerified: false, actualModelVerified: false });
+    });
+    it('does not silently treat Claude as Codex during native discovery', async () => {
+        const queryCodexModelCatalog = jest.fn();
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { queryCodexModelCatalog });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'discover', '--provider', 'claude-code', '--json']);
+        expect(JSON.parse(String(out.mock.calls[0][0]))).toMatchObject({ state: 'unverified', provider: 'claude-code' });
+        expect(queryCodexModelCatalog).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(2);
+    });
+    it('reports every Codex selection and the full fallback as unverified without dispatch', async () => {
+        const cheap = { selector: { kind: 'model', id: 'gpt-6-sol' }, effort: { kind: 'explicit', value: 'low' } };
+        const full = { selector: { kind: 'model', id: 'gpt-6-astra' }, effort: { kind: 'explicit', value: 'high' } };
+        const queryCodexModelCatalog = jest.fn(async () => ({ provenance: 'native-catalog', selections: [cheap, full], nativeDispatchVerified: false, actualModelVerified: false }));
+        const queryCodexMachineFacts = jest.fn(async () => ({ provenance: 'codex-app-server-config-account', configDigest: 'c'.repeat(64), accountState: 'identified', accountScopeDigest: 'a'.repeat(64), inferenceDispatched: false }));
+        const queryRuntimeExecutable = jest.fn(async () => ({ version: '0.156.0', binaryDigest: 'b'.repeat(64), inferenceDispatched: false }));
+        const ensureMachineKey = jest.fn(() => Buffer.alloc(32, 7));
+        const readEffectivePolicy = jest.fn(() => ({ state: 'approved', policy: { content: { mappings: [{ target: 'codex', runtimeKind: 'native', profiles: { mechanical: cheap, integration: cheap, judgment: full }, fullCapability: full, degradation: { allowMissingObservedIdentity: false } }] } } }));
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { queryCodexModelCatalog, queryCodexMachineFacts, queryRuntimeExecutable, ensureMachineKey, readEffectivePolicy: readEffectivePolicy });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'setup', '--provider', 'codex', '--json']);
+        const report = JSON.parse(String(out.mock.calls[0][0]));
+        expect(report).toMatchObject({ state: 'setup-pending', provider: 'codex', inferenceDispatched: false, tokenUsage: 'unknown', nativeDispatchVerified: false, actualModelVerified: false,
+            machine: { runtimeVersion: '0.156.0', binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64), accountState: 'identified', accountScopeDigest: 'a'.repeat(64) } });
+        expect(report.selections).toEqual(expect.arrayContaining([
+            expect.objectContaining({ role: 'mechanical', catalogAvailable: true, dispatch: 'untested' }),
+            expect.objectContaining({ role: 'fullCapability', catalogAvailable: true, dispatch: 'untested' }),
+        ]));
+        expect(report.policyAction).toMatch(/allowMissingObservedIdentity/);
+        expect(queryCodexModelCatalog).toHaveBeenCalledTimes(1);
+        expect(queryCodexMachineFacts).toHaveBeenCalledTimes(1);
+        expect(queryRuntimeExecutable).toHaveBeenCalledTimes(1);
+        expect(ensureMachineKey).toHaveBeenCalledTimes(1);
+        expect(process.exitCode).toBe(2);
+    });
+    it('never runs inference merely because setup was requested', async () => {
+        const queryCodexModelCatalog = jest.fn();
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { queryCodexModelCatalog });
+        await expect(program.parseAsync(['node', 'awm', 'model-policy', 'setup', '--provider', 'codex', '--allow-inference'])).rejects.toThrow(/unknown option/i);
+        expect(queryCodexModelCatalog).not.toHaveBeenCalled();
+    });
+    it('captures only an approved Codex selection from an existing native child, with local scope', async () => {
+        const selected = { selector: { kind: 'model', id: 'gpt-6-luna' }, effort: { kind: 'explicit', value: 'high' } };
+        const mapping = { target: 'codex', runtimeKind: 'native', profiles: { mechanical: selected, integration: selected, judgment: selected }, fullCapability: selected,
+            degradation: { allowMissingModelOverride: false, allowMissingEffortOverride: false, allowMissingObservedIdentity: true } };
+        const queryCodexChildThreadObservation = jest.fn(async () => ({ configuredSelection: selected, childRuntimeVersion: '0.156.1', observedAt: '2026-09-23T01:00:00.000Z' }));
+        const publishCodexObservation = jest.fn(() => ({ schema: 'routing-capabilities/v2', claims: [{ selection: selected }] }));
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { readEffectivePolicy: (() => ({ state: 'approved', policy: { content: { mappings: [mapping] } } })),
+            queryCodexChildThreadObservation: queryCodexChildThreadObservation, publishCodexObservation: publishCodexObservation,
+            queryCodexMachineFacts: (async () => ({ configDigest: 'c'.repeat(64), accountScopeDigest: 'a'.repeat(64), accountState: 'identified' })),
+            queryRuntimeExecutable: (async () => ({ version: '0.156.1', binaryDigest: 'b'.repeat(64) })),
+            ensureMachineKey: (() => Buffer.alloc(32, 7)) });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'capture', '--provider', 'codex', '--runtime-kind', 'native', '--parent-thread-id', 'parent-1', '--child-thread-id', 'child-1', '--json']);
+        expect(queryCodexChildThreadObservation).toHaveBeenCalledWith(expect.objectContaining({ parentThreadId: 'parent-1', childThreadId: 'child-1' }));
+        expect(publishCodexObservation).toHaveBeenCalledWith(expect.objectContaining({ expectedSelection: selected,
+            scope: { runtime: { target: 'codex', kind: 'native', version: '0.156.1', accountScopeDigest: 'a'.repeat(64) }, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) } }));
+        expect(JSON.parse(String(out.mock.calls[0][0]))).toMatchObject({ state: 'captured', actualModelVerified: false, tokenUsage: 'unknown' });
+    });
+    it('reports a matching event-scoped enrollment as ready after 25 hours without refreshing it', async () => {
+        const selected = { selector: { kind: 'model', id: 'gpt-6-luna' }, effort: { kind: 'explicit', value: 'high' } };
+        const mapping = { target: 'codex', runtimeKind: 'native', profiles: { mechanical: selected, integration: selected, judgment: selected }, fullCapability: selected,
+            degradation: { allowMissingModelOverride: false, allowMissingEffortOverride: false, allowMissingObservedIdentity: true } };
+        const { createHash } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const mappingDigest = createHash('sha256').update(JSON.stringify({ target: mapping.target, runtimeKind: mapping.runtimeKind, selection: selected })).digest('hex');
+        const receipt = { schema: 'routing-capabilities/v2', runtime: { target: 'codex', kind: 'native', version: '0.156.1', accountScopeDigest: 'a'.repeat(64) },
+            binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64), recordedAt: '2026-09-22T01:00:00.000Z', claims: [{ selection: selected, mappingDigest,
+                    eventDigest: 'e'.repeat(64), source: 'codex-turn-context', observedAt: '2026-09-22T00:59:00.000Z', actualModel: 'unverified', tokenUsage: 'unknown' }] };
+        const readStoredEventReceipt = jest.fn(() => ({ state: 'present', receipt }));
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { readEffectivePolicy: (() => ({ state: 'approved', policy: { content: { mappings: [mapping] } } })),
+            readStoredEventReceipt: readStoredEventReceipt,
+            queryCodexModelCatalog: (async () => ({ selections: [selected] })),
+            queryCodexMachineFacts: (async () => ({ configDigest: 'c'.repeat(64), accountScopeDigest: 'a'.repeat(64), accountState: 'identified' })),
+            queryRuntimeExecutable: (async () => ({ version: '0.156.1', binaryDigest: 'b'.repeat(64) })),
+            ensureMachineKey: (() => Buffer.alloc(32, 7)) });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'setup', '--provider', 'codex', '--json']);
+        expect(JSON.parse(String(out.mock.calls[0][0]))).toMatchObject({ state: 'ready-operational', selections: expect.arrayContaining([expect.objectContaining({ dispatch: 'verified', acceptedSelection: 'verified', actualModel: 'untested' })]) });
+        expect(readStoredEventReceipt).toHaveBeenCalledTimes(1);
+        expect(process.exitCode).toBeUndefined();
+    });
+    it('discovers Claude version and account without claiming a model or dispatch', async () => {
+        const selected = { selector: { kind: 'model', id: 'claude-sonnet-4-6' }, effort: { kind: 'runtime-default' } };
+        const mapping = { target: 'claude-code', runtimeKind: 'native', profiles: { mechanical: selected, integration: selected, judgment: selected }, fullCapability: selected,
+            degradation: { allowMissingModelOverride: false, allowMissingEffortOverride: false, allowMissingObservedIdentity: false } };
+        const queryClaudeAuthStatus = jest.fn(async () => ({ accountState: 'identified', accountScopeDigest: 'a'.repeat(64), inferenceDispatched: false }));
+        const queryRuntimeExecutable = jest.fn(async () => ({ version: '2.1.263', binaryDigest: 'b'.repeat(64), inferenceDispatched: false }));
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({ writeErr: () => undefined });
+        (0, model_policy_1.registerModelPolicyCommand)(program, { readEffectivePolicy: (() => ({ state: 'approved', policy: { content: { mappings: [mapping] } } })),
+            queryClaudeAuthStatus: queryClaudeAuthStatus, queryRuntimeExecutable: queryRuntimeExecutable,
+            readClaudeModelConfigDigest: (() => 'c'.repeat(64)),
+            ensureMachineKey: (() => Buffer.alloc(32, 7)) });
+        await program.parseAsync(['node', 'awm', 'model-policy', 'setup', '--provider', 'claude-code', '--json']);
+        expect(JSON.parse(String(out.mock.calls[0][0]))).toMatchObject({ state: 'setup-pending', provider: 'claude-code', machine: { runtimeVersion: '2.1.263', accountState: 'identified', configState: 'local-fingerprint' },
+            nativeDispatchVerified: false, actualModelVerified: false, inferenceDispatched: false });
+        expect(queryClaudeAuthStatus).toHaveBeenCalledTimes(1);
+    });
 });

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

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -11,6 +44,8 @@ const checks_1 = require("../../../src/commands/preflight/checks");
 const preflight_1 = require("../../../src/commands/preflight");
 const run_1 = require("../../../src/commands/sensors/run");
 const check_1 = require("../../../src/core/currentness/check");
+const store_1 = require("../../../src/core/model-policy/store");
+const setupReadiness = __importStar(require("../../../src/core/model-policy/setup-readiness"));
 // Only `execSync` (used by `resolveOnPath` to check for `gh`/`glab`) is mocked — `git
 // remote get-url origin` runs for real via `execFileSync` against real tmpdir git repos,
 // same as every other check in this file exercises the real filesystem.
@@ -25,8 +60,13 @@ jest.mock('../../../src/commands/sensors/run', () => ({
 jest.mock('../../../src/core/currentness/check', () => ({
     checkCurrentness: jest.fn(),
 }));
+jest.mock('../../../src/core/model-policy/store', () => ({
+    ...jest.requireActual('../../../src/core/model-policy/store'),
+    readEffectivePolicy: jest.fn(),
+}));
 const mockRunSensors = run_1.runSensors;
 const mockCheckCurrentness = check_1.checkCurrentness;
+const mockReadEffectivePolicy = store_1.readEffectivePolicy;
 /** Turn a tmpdir into a real git repo with (optionally) an `origin` remote. */
 function gitRepo(dir, remoteUrl) {
     (0, child_process_1.execFileSync)('git', ['init'], { cwd: dir, stdio: 'pipe' });
@@ -104,6 +144,7 @@ function writePartialKernel(dir) {
 const check = (r, id) => r.checks.find(c => c.id === id);
 describe('preflight', () => {
     beforeEach(() => {
+        mockReadEffectivePolicy.mockReturnValue({ state: 'absent' });
         mockCheckCurrentness.mockResolvedValue({
             checkedAt: '2026-08-26T00:00:00.000Z',
             compatibility: { status: 'not-checked' },
@@ -115,6 +156,30 @@ describe('preflight', () => {
                 }],
         });
     });
+    it('advises machine model setup for an approved mapping without degrading ordinary harness readiness', async () => {
+        mockReadEffectivePolicy.mockReturnValue({
+            state: 'approved', provenance: 'user',
+            policy: { content: { mappings: [{ target: 'codex', runtimeKind: 'native' }] } },
+        });
+        const report = await (0, checks_1.preflight)(make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } }));
+        expect(check(report, 'routing-setup')).toMatchObject({ advisory: true, ok: false, remedy: 'awm model-policy setup --provider codex --json' });
+        expect(report.status).toBe('ready');
+    });
+    it('labels sealed local coverage without claiming current machine verification or demanding setup', async () => {
+        const guidance = jest.spyOn(setupReadiness, 'routingSetupGuidance').mockReturnValueOnce([
+            { target: 'codex', runtimeKind: 'native', state: 'coverage-only' },
+        ]);
+        try {
+            const report = await (0, checks_1.preflight)(make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } }));
+            expect(check(report, 'routing-setup')).toMatchObject({ advisory: true, ok: true,
+                detail: expect.stringContaining('do not verify current runtime/account/config scope') });
+            expect(check(report, 'routing-setup').remedy).toBeUndefined();
+            expect(report.status).toBe('ready');
+        }
+        finally {
+            guidance.mockRestore();
+        }
+    });
     afterEach(() => {
         mockRunSensors.mockReset();
         mockCheckCurrentness.mockReset();

package/dist/tests/commands/watch/apply.test.js

@@ -50,6 +50,11 @@ const gate_1 = require("../../../src/commands/job/gate");
 const canonical_1 = require("../../../src/core/model-policy/canonical");
 const capabilities_1 = require("../../../src/core/model-policy/capabilities");
 const routing_approval_1 = require("../../helpers/routing-approval");
+const machine_key_1 = require("../../../src/core/model-policy/machine-key");
+const native_routing_proof_1 = require("../../../src/core/model-policy/native-routing-proof");
+const eventStore = __importStar(require("../../../src/core/model-policy/event-store"));
+const policyStore = __importStar(require("../../../src/core/model-policy/store"));
+const selection_policy_digest_1 = require("../../../src/core/model-policy/selection-policy-digest");
 function jobPayload(argv) {
     return { argv, paths: [], cwd: '.', fingerprint: 'fp-1', commandDigest: 'cd-1', expandedPaths: [] };
 }
@@ -228,6 +233,85 @@ describe('aplicacion transaccional de requests', () => {
                 process.env.AWM_HOME = priorHome;
         }
     });
+    test('un recibo nativo v2 no acepta una observacion positiva redactada por el agente', () => {
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.routingAttempts = [{ schema: 'routing-attempt/v1', id: 'route-native-1', obligationId: 'o1', lineageId: 'l1', attempt: 1,
+                envelope: routing_approval_1.routingEnvelope, envelopeDigest: 'a'.repeat(64), fingerprint: 'b'.repeat(64), state: 'reserved',
+                nativeEvidenceRequired: true, reservedAt: new Date(Date.now() - 1_000).toISOString() }];
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'routing-observe', generationToken: 'g1', idempotencyKey: 'forged-positive',
+            payload: { attemptId: 'route-native-1', nativeAgentId: 'fake-child', observed: routing_approval_1.routingEnvelope.resolved } });
+        const result = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect({ result, problems: (0, store_1.readJournal)(repo, 'rama').state?.requestProblems }).toMatchObject({ result: { applied: 1 } });
+        const after = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(after.routingAttempts?.[0]).toMatchObject({ state: 'blocked', reasonCode: 'PROVENANCE_MISSING', verdict: 'inconclusive' });
+        expect(after.routingIncidents).toMatchObject([{ reasonCode: 'PROVENANCE_MISSING', alertState: 'pending' }]);
+    });
+    test('un evento nativo sellado posterior a la reserva activa solo su intento', () => {
+        const previousHome = process.env.AWM_HOME;
+        const operator = path_1.default.join(repo, 'operator');
+        fs_1.default.mkdirSync(operator);
+        process.env.AWM_HOME = operator;
+        const scope = { runtime: routing_approval_1.routingEnvelope.runtime, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+        const approved = (0, routing_approval_1.routingApproval)().policy;
+        const enrolledAt = new Date(Date.now() - 1_000).toISOString();
+        const eventReader = jest.spyOn(eventStore, 'readStoredEventReceipt').mockReturnValue({ state: 'present', receipt: {
+                schema: 'routing-capabilities/v2', ...scope, recordedAt: enrolledAt, claims: [{
+                        selection: routing_approval_1.routingEnvelope.resolved, mappingDigest: (0, selection_policy_digest_1.selectionPolicyDigest)(approved.content.mappings[0], routing_approval_1.routingEnvelope.resolved),
+                        eventDigest: 'c'.repeat(64), source: 'codex-turn-context', observedAt: enrolledAt,
+                        actualModel: 'unverified', tokenUsage: 'unknown'
+                    }],
+            } });
+        const policyReader = jest.spyOn(policyStore, 'readEffectivePolicy').mockReturnValue({ state: 'approved', provenance: 'project', policy: approved });
+        try {
+            const reservedAt = new Date(Date.now() - 2_000).toISOString();
+            const state = (0, store_1.readJournal)(repo, 'rama').state;
+            state.routingAttempts = [{ schema: 'routing-attempt/v1', id: 'route-native-1', obligationId: 'o1', lineageId: 'l1', attempt: 1,
+                    envelope: routing_approval_1.routingEnvelope, envelopeDigest: 'a'.repeat(64), fingerprint: 'b'.repeat(64), state: 'reserved',
+                    nativeEvidenceRequired: true, reservedAt }];
+            (0, store_1.writeJournal)(repo, 'rama', state);
+            const proof = (0, native_routing_proof_1.signNativeRoutingProof)({ attemptId: 'route-native-1', nativeAgentId: 'child-1', source: 'codex-turn-context',
+                eventDigest: 'c'.repeat(64), observedAt: new Date(Date.now() - 1_000).toISOString(), selection: routing_approval_1.routingEnvelope.resolved }, (0, machine_key_1.ensureMachineKey)(operator));
+            (0, requests_1.emitRequest)(repo, 'rama', { kind: 'routing-observe', generationToken: 'g1', idempotencyKey: 'native-positive',
+                payload: { attemptId: 'route-native-1', nativeAgentId: 'child-1', observed: routing_approval_1.routingEnvelope.resolved, nativeProof: proof } });
+            expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1', scope).applied).toBe(1);
+            expect((0, store_1.readJournal)(repo, 'rama').state.routingAttempts?.[0]).toMatchObject({ state: 'active', nativeEventDigest: 'c'.repeat(64) });
+        }
+        finally {
+            eventReader.mockRestore();
+            policyReader.mockRestore();
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+        }
+    });
+    test('un proof en cola no activa el intento sin scope local vigente', () => {
+        const previousHome = process.env.AWM_HOME;
+        const operator = path_1.default.join(repo, 'operator');
+        fs_1.default.mkdirSync(operator);
+        process.env.AWM_HOME = operator;
+        try {
+            const state = (0, store_1.readJournal)(repo, 'rama').state;
+            const reservedAt = new Date(Date.now() - 2_000).toISOString();
+            state.routingAttempts = [{ schema: 'routing-attempt/v1', id: 'route-native-1', obligationId: 'o1', lineageId: 'l1', attempt: 1,
+                    envelope: routing_approval_1.routingEnvelope, envelopeDigest: 'a'.repeat(64), fingerprint: 'b'.repeat(64), state: 'reserved',
+                    nativeEvidenceRequired: true, reservedAt }];
+            (0, store_1.writeJournal)(repo, 'rama', state);
+            const proof = (0, native_routing_proof_1.signNativeRoutingProof)({ attemptId: 'route-native-1', nativeAgentId: 'child-1', source: 'codex-turn-context',
+                eventDigest: 'c'.repeat(64), observedAt: new Date(Date.now() - 1_000).toISOString(), selection: routing_approval_1.routingEnvelope.resolved }, (0, machine_key_1.ensureMachineKey)(operator));
+            (0, requests_1.emitRequest)(repo, 'rama', { kind: 'routing-observe', generationToken: 'g1', idempotencyKey: 'native-stale-scope',
+                payload: { attemptId: 'route-native-1', nativeAgentId: 'child-1', observed: routing_approval_1.routingEnvelope.resolved, nativeProof: proof } });
+            (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+            expect((0, store_1.readJournal)(repo, 'rama').state.routingAttempts?.[0]).toMatchObject({ state: 'blocked', reasonCode: 'PROVENANCE_MISSING' });
+        }
+        finally {
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+        }
+    });
     test('request corrupta se aparta VISIBLE como .corrupt, jamas se descarta (R1.6)', () => {
         fs_1.default.writeFileSync(path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'req-roto.json'), '{no-json');
         const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');

package/dist/tests/commands/watch/dispatch-routing-identity.test.js

@@ -149,6 +149,29 @@ describe('the supervisor admission actually carries the identity (#166)', () =>
             fs_1.default.rmSync(repo, { recursive: true, force: true });
         }
     });
+    test('uses sealed event evidence and a freshly measured Codex scope instead of a 24h receipt', async () => {
+        const repo = boundRepo();
+        try {
+            const runtime = { target: 'codex', kind: 'native', version: '0.156.1', accountScopeDigest: DIGEST };
+            const eventScope = { runtime, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+            const eventReceipt = { schema: 'routing-capabilities/v2', ...eventScope, recordedAt: '2026-09-22T00:00:00.000Z', claims: [] };
+            const seen = [];
+            const readCapabilities = jest.fn();
+            const admission = (0, supervisor_1.defaultDispatchAdmission)(repo, 'main', 'codex', { kind: 'native', version: '0.156.1', accountScopeDigest: DIGEST }, {
+                admit: (async (input) => { seen.push(input); return { state: 'admitted' }; }),
+                readEffectivePolicy: () => ({ state: 'absent' }),
+                readCapabilities,
+                readStoredEventReceipt: (() => ({ state: 'present', receipt: eventReceipt })),
+                queryLocalCodexScope: (async () => ({ state: 'current', scope: eventScope })),
+            });
+            await admission();
+            expect(readCapabilities).not.toHaveBeenCalled();
+            expect(seen[0].routing).toMatchObject({ runtime, eventScope, eventReceipt });
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
     test('dispatches without routing facts when no identity was asserted', async () => {
         const repo = boundRepo();
         try {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const admission_1 = require("../../../src/core/admission");
 const types_1 = require("../../../src/core/journal/types");
+const selection_policy_digest_1 = require("../../../src/core/model-policy/selection-policy-digest");
 const valid = {
     state: 'valid', schema: 'compact-slices/v1', planDigest: 'a'.repeat(64),
     manifest: {
@@ -50,6 +51,26 @@ describe('admitPlan', () => {
         const report = await (0, admission_1.admitPlan)({ plan: v2(profile), provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], routing: routing() });
         expect(report).toMatchObject({ state: 'admitted', routingForecast: { implementerProfiles: { [profile]: 1 }, trackB: { state: 'unavailable', lowerBound: 1 }, controller: { state: 'unavailable', lowerBound: 0 } } });
     });
+    it('awaits read-only routing evidence only after earlier admission gates pass', async () => {
+        const reader = jest.fn(async () => routing());
+        expect(await (0, admission_1.admitPlan)({ plan: v2(), provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], routingReader: reader })).toMatchObject({ state: 'admitted' });
+        expect(reader).toHaveBeenCalledTimes(1);
+    });
+    it('admits a +25h event-scoped Codex enrollment only when the full fallback is independently proved', async () => {
+        const evidence = routing();
+        evidence.policy.content.mappings[0].degradation.allowMissingObservedIdentity = true;
+        const mapping = evidence.policy.content.mappings[0];
+        const eventScope = { runtime: evidence.runtime, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+        const claimed = [mapping.profiles.mechanical, mapping.fullCapability];
+        const eventReceipt = { schema: 'routing-capabilities/v2', ...eventScope, recordedAt: '2026-09-17T00:00:00.000Z', claims: claimed.map(selection => ({ selection,
+                mappingDigest: (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, selection), eventDigest: sha, source: 'codex-turn-context', observedAt: '2026-09-17T00:00:00.000Z', actualModel: 'unverified', tokenUsage: 'unknown' })) };
+        const routingFacts = { runtime: evidence.runtime, policy: evidence.policy, eventReceipt, eventScope, now: new Date('2026-09-18T01:00:00.000Z') };
+        expect(await (0, admission_1.admitPlan)({ plan: v2(), provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], routing: routingFacts })).toMatchObject({ state: 'admitted' });
+        expect(await (0, admission_1.admitPlan)({ plan: v2(), provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], routing: { ...routingFacts,
+                eventReceipt: { ...eventReceipt, claims: [eventReceipt.claims[1]] } } })).toMatchObject({ state: 'admitted' });
+        expect(await (0, admission_1.admitPlan)({ plan: v2(), provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], routing: { ...routingFacts,
+                eventReceipt: { ...eventReceipt, claims: [eventReceipt.claims[0]] } } })).toMatchObject({ state: 'blocked', diagnostics: [{ code: 'ROUTING_SELECTION_UNENROLLED' }] });
+    });
     it('blocks a valid cross-provider policy and receipt instead of admitting codex under another runtime target', async () => {
         const evidence = routing();
         const foreign = structuredClone(evidence);