agentic-workflow-manager 9.11.11 → 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

@@ -11,20 +11,26 @@ const commander_1 = require("commander");
 const job_1 = require("../../../src/commands/job");
 const store_1 = require("../../../src/core/journal/store");
 const journal_1 = require("../../../src/core/model-policy/journal");
-const envelope = { schema: 'routing-envelope/v1', runtime: { target: 'codex', kind: 'native', version: '1', accountScopeDigest: '0'.repeat(64) }, role: 'implementer', sliceId: 'S1', requestedProfile: 'mechanical', effectiveProfile: 'mechanical', resolved: { selector: { kind: 'model', id: 'model-private' }, effort: { kind: 'explicit', value: 'medium' } }, outcome: 'native', unavailableEvidence: [], policyDigest: 'a'.repeat(64), capabilityDigest: 'b'.repeat(64), planDigest: 'c'.repeat(64), executionDigest: 'd'.repeat(64) };
+const capabilities_1 = require("../../../src/core/model-policy/capabilities");
+const routing_approval_1 = require("../../helpers/routing-approval");
 function gitInit(repo) {
     (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', 'init', '-q', '-b', 'main'], { cwd: repo });
     fs_1.default.writeFileSync(path_1.default.join(repo, 'fixture'), 'x');
     (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);
         (0, store_1.initJournal)(repo, 'main');
         const state = (0, store_1.readJournal)(repo, 'main').state;
-        const reserved = (0, journal_1.reserveRoutingAttempt)(state, { obligationId: 'obligation', lineageId: 'lineage', envelope, fingerprint: 'e'.repeat(64) }, '2026-09-17T00:00:00.000Z');
+        const approved = (0, routing_approval_1.routingApproval)();
+        const privateSelection = { ...routing_approval_1.routingEnvelope.resolved, selector: { kind: 'model', id: 'model-private' } };
+        approved.policy.content.mappings[0].profiles.mechanical = privateSelection;
+        approved.capabilities.availableSelections.push(privateSelection);
+        const envelope = { ...routing_approval_1.routingEnvelope, resolved: privateSelection, capabilityDigest: (0, capabilities_1.capabilityReceiptDigest)(approved.capabilities) };
+        const reserved = (0, journal_1.reserveRoutingAttempt)(state, { obligationId: 'obligation', lineageId: 'lineage', envelope, fingerprint: 'e'.repeat(64), approval: () => approved }, '2026-09-17T00:00:00.000Z');
         (0, store_1.writeJournal)(repo, 'main', (0, journal_1.observeRoutingAttempt)(reserved.state, { attemptId: reserved.attemptId, nativeAgentId: 'native-private' }, '2026-09-17T00:01:00.000Z'));
         const program = new commander_1.Command();
         program.exitOverride();
@@ -34,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/job/routing.test.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("../../../src/core/journal/types");
 const journal_1 = require("../../../src/core/model-policy/journal");
-const envelope = { schema: 'routing-envelope/v1', runtime: { target: 'codex', kind: 'native', version: '1', accountScopeDigest: '0'.repeat(64) }, role: 'implementer', sliceId: 'S1', requestedProfile: 'mechanical', effectiveProfile: 'mechanical', resolved: { selector: { kind: 'model', id: 'm' }, effort: { kind: 'explicit', value: 'medium' } }, outcome: 'native', unavailableEvidence: [], policyDigest: 'a'.repeat(64), capabilityDigest: 'b'.repeat(64), planDigest: 'c'.repeat(64), executionDigest: 'd'.repeat(64) };
+const routing_approval_1 = require("../../helpers/routing-approval");
 test('routing report remains read-only across an observed attempt', () => {
-    const reserved = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'o1', lineageId: 'l1', envelope, fingerprint: 'e'.repeat(64) }, '2026-09-17T00:00:00.000Z');
+    const reserved = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'o1', lineageId: 'l1', envelope: routing_approval_1.routingEnvelope, fingerprint: 'e'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z');
     const observed = (0, journal_1.observeRoutingAttempt)(reserved.state, { attemptId: reserved.attemptId, nativeAgentId: 'native-id' }, '2026-09-17T00:01:00.000Z');
     expect((0, journal_1.routingReport)(observed)).toMatchObject({ attempts: 1, byState: { active: 1 } });
     expect(observed.routingAttempts[0].nativeAgentId).toBe('native-id');

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/plan/index.test.js

@@ -84,7 +84,7 @@ describe('plan validate Commander wiring', () => {
         // not come out of validatePlanFile, so a spread-and-relabel fixture
         // cannot reach this path at all.
         const sliceId = 'S1';
-        const sel = { selector: { kind: 'model', id: 'gpt-5.6-luna' }, effort: { kind: 'explicit', value: 'medium' } };
+        const sel = { selector: { kind: 'model', id: 'gpt-5.6-luna' }, effort: { kind: 'explicit', value: 'high' } };
         const full = { selector: { kind: 'model', id: 'gpt-5.6-sol' }, effort: { kind: 'explicit', value: 'high' } };
         const sha = 'a'.repeat(64);
         const content = { schema: 'model-policy/v1', mappings: [{ target: 'codex', runtimeKind: 'native', profiles: { mechanical: sel, integration: sel, judgment: sel }, fullCapability: full, degradation: { allowMissingModelOverride: false, allowMissingEffortOverride: false, allowMissingObservedIdentity: false } }], implementationBudget: { maxAttempts: 3, escalation: ['mechanical', 'integration', 'judgment'], judgmentEfforts: ['medium', 'high'] } };
@@ -115,7 +115,7 @@ describe('plan validate Commander wiring', () => {
         expect(emitted.envelope.executionDigest).toBe(v2Valid.executionDigest);
         // The point of the whole thing: that envelope reserves a first attempt,
         // which is what creates the lineage the escalation path later needs.
-        const reserved = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'o1', lineageId: 'l1', envelope: emitted.envelope, fingerprint: 'e'.repeat(64) }, '2026-09-19T00:00:00.000Z');
+        const reserved = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'o1', lineageId: 'l1', envelope: emitted.envelope, fingerprint: 'e'.repeat(64), approval: () => ({ policy: readEffectivePolicy().policy, capabilities: receipt, checkedAt: new Date() }) }, '2026-09-19T00:00:00.000Z');
         expect(reserved.attemptId).toEqual(expect.any(String));
         expect(reserved.state.implementationLineages).toEqual([expect.objectContaining({ id: 'l1', sliceId, initialProfile: 'mechanical' })]);
     });

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();