agentic-workflow-manager 9.11.12 → 9.12.1

package/dist/tests/core/model-policy/hook-diagnostics.test.js

@@ -0,0 +1,34 @@
+"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 hook_diagnostics_1 = require("../../../src/core/model-policy/hook-diagnostics");
+describe('durable Claude hook diagnostics', () => {
+    it('alerts once per unresolved cause and retains a named failure until native capture recovers', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-hook-diagnostic-'));
+        const previous = process.env.AWM_HOME;
+        process.env.AWM_HOME = root;
+        try {
+            expect((0, hook_diagnostics_1.readRoutingHookStatus)()).toEqual({ state: 'absent' });
+            expect((0, hook_diagnostics_1.recordRoutingHookStatus)('stop', 'HOOK_TRANSCRIPT_UNVERIFIED', new Date('2026-09-23T01:00:00.000Z'))).toBe(true);
+            expect((0, hook_diagnostics_1.recordRoutingHookStatus)('stop', 'HOOK_TRANSCRIPT_UNVERIFIED', new Date('2026-09-23T01:01:00.000Z'))).toBe(false);
+            expect((0, hook_diagnostics_1.readRoutingHookStatus)()).toEqual({ state: 'failed', failures: [{ phase: 'stop', reasonCode: 'HOOK_TRANSCRIPT_UNVERIFIED', count: 2 }] });
+            expect((0, hook_diagnostics_1.recordRoutingHookStatus)('stop', 'success', new Date('2026-09-23T01:02:00.000Z'))).toBe(false);
+            expect((0, hook_diagnostics_1.readRoutingHookStatus)()).toEqual({ state: 'healthy' });
+            const file = path_1.default.join(root, 'routing-hook-status.json');
+            fs_1.default.writeFileSync(file, '{"schema":"routing-hook-status/v1","start":{},"stop":{}}');
+            expect((0, hook_diagnostics_1.readRoutingHookStatus)()).toEqual({ state: 'invalid' });
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previous;
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/model-policy/journal.test.js

@@ -4,6 +4,8 @@ const types_1 = require("../../../src/core/journal/types");
 const journal_1 = require("../../../src/core/model-policy/journal");
 const capabilities_1 = require("../../../src/core/model-policy/capabilities");
 const routing_approval_1 = require("../../helpers/routing-approval");
+const selection_policy_digest_1 = require("../../../src/core/model-policy/selection-policy-digest");
+const resolve_1 = require("../../../src/core/model-policy/resolve");
 describe('routing journal helpers', () => {
     it('reserves one idempotent attempt and records native observation', () => {
         const state = (0, types_1.emptyState)('main');
@@ -13,6 +15,73 @@ describe('routing journal helpers', () => {
         const observed = (0, journal_1.observeRoutingAttempt)(replay.state, { attemptId: reserved.attemptId, nativeAgentId: 'native-1' }, '2026-09-17T00:02:00.000Z');
         expect(observed.routingAttempts?.[0]).toMatchObject({ state: 'active', nativeAgentId: 'native-1' });
     });
+    it('persists a mismatch as one alertable blocked incident without renewing capability', () => {
+        const state = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: routing_approval_1.routingEnvelope,
+            fingerprint: 'e'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z').state;
+        const attemptId = state.routingAttempts[0].id;
+        const mismatched = (0, journal_1.observeRoutingAttempt)(state, { attemptId, nativeAgentId: 'native-1', observed: { ...(0, routing_approval_1.routingSelection)('high'), selector: { kind: 'model', id: 'different' } } }, '2026-09-17T00:02:00.000Z');
+        expect(mismatched.routingAttempts?.[0]).toMatchObject({ state: 'blocked', verdict: 'inconclusive', reasonCode: 'SELECTION_MISMATCH' });
+        expect(mismatched.routingIncidents).toMatchObject([{ reasonCode: 'SELECTION_MISMATCH', blockedCount: 1, fallbackCount: 0, alertState: 'pending' }]);
+        expect((0, journal_1.observeRoutingAttempt)(mismatched, { attemptId, nativeAgentId: 'native-1', observed: { ...(0, routing_approval_1.routingSelection)('high'), selector: { kind: 'model', id: 'different' } } }, '2026-09-17T00:03:00.000Z')).toEqual(mismatched);
+        expect(state.routingIncidents).toBeUndefined();
+    });
+    it('persists missing native provenance as a blocked incident, not an active optimized attempt', () => {
+        const state = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: routing_approval_1.routingEnvelope,
+            fingerprint: 'e'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z').state;
+        const attemptId = state.routingAttempts[0].id;
+        const missing = (0, journal_1.observeRoutingAttempt)(state, { attemptId, nativeAgentId: 'native-1', unavailableReason: 'PROVENANCE_MISSING' }, '2026-09-17T00:02:00.000Z');
+        expect(missing.routingAttempts?.[0]).toMatchObject({ state: 'blocked', verdict: 'inconclusive', reasonCode: 'PROVENANCE_MISSING' });
+        expect(missing.routingIncidents).toMatchObject([{ reasonCode: 'PROVENANCE_MISSING', blockedCount: 1, alertState: 'pending' }]);
+    });
+    it('reserves a separately proved full fallback and records why optimization was skipped', () => {
+        const approved = (0, routing_approval_1.routingApproval)();
+        approved.policy.content.mappings[0].degradation.allowMissingObservedIdentity = true;
+        const eventScope = { runtime: routing_approval_1.routingEnvelope.runtime, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+        const full = approved.policy.content.mappings[0].fullCapability;
+        const eventReceipt = { schema: 'routing-capabilities/v2', ...eventScope, recordedAt: '2026-09-17T00:00:00.000Z', claims: [{ selection: full,
+                    mappingDigest: (0, selection_policy_digest_1.selectionPolicyDigest)(approved.policy.content.mappings[0], full), eventDigest: 'e'.repeat(64), source: 'codex-turn-context',
+                    observedAt: '2026-09-17T00:00:00.000Z', actualModel: 'unverified', tokenUsage: 'unknown' }] };
+        const result = (0, resolve_1.resolveEventWithFallback)({ role: 'implementer', requestedProfile: 'mechanical', policy: approved.policy, receipt: eventReceipt, scope: eventScope, now: approved.checkedAt });
+        if (result.state !== 'resolved')
+            throw new Error('full fallback must resolve');
+        const routed = { ...routing_approval_1.routingEnvelope, effectiveProfile: 'full', resolved: full, outcome: result.outcome, unavailableEvidence: result.unavailableEvidence,
+            capabilityDigest: result.capabilityDigest };
+        const reserved = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: routed,
+            fingerprint: 'f'.repeat(64), approval: () => ({ policy: approved.policy, eventReceipt, eventScope, checkedAt: approved.checkedAt }) }, '2026-09-17T00:00:00.000Z');
+        expect(reserved.state.routingAttempts?.[0]).toMatchObject({ state: 'reserved', reasonCode: 'ROUTING_SELECTION_UNENROLLED', envelope: { effectiveProfile: 'full' } });
+        expect((0, journal_1.routingReport)(reserved.state)).toMatchObject({ fallbacks: 1, unavailable: { observedModelEvidence: 1, ROUTING_SELECTION_UNENROLLED: 1 } });
+        expect(reserved.state.routingIncidents).toMatchObject([{ reasonCode: 'ROUTING_SELECTION_UNENROLLED', affectedObligations: 1, fallbackCount: 1, blockedCount: 0, alertState: 'pending' }]);
+        expect((0, journal_1.routingReport)(reserved.state)).toMatchObject({ incidents: [expect.objectContaining({ reasonCode: 'ROUTING_SELECTION_UNENROLLED', fallbackCount: 1, alertState: 'pending' })] });
+    });
+    it('reserves verified full capability after an optimized provider rejection in the same lineage', () => {
+        const approved = (0, routing_approval_1.routingApproval)();
+        approved.policy.content.mappings[0].degradation.allowMissingObservedIdentity = true;
+        const mapping = approved.policy.content.mappings[0];
+        const eventScope = { runtime: routing_approval_1.routingEnvelope.runtime, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+        const eventReceipt = { schema: 'routing-capabilities/v2', ...eventScope, recordedAt: '2026-09-17T00:00:00.000Z', claims: [mapping.profiles.mechanical, mapping.fullCapability].map(selected => ({ selection: selected,
+                mappingDigest: (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, selected), eventDigest: 'e'.repeat(64), source: 'codex-turn-context',
+                observedAt: '2026-09-17T00:00:00.000Z', actualModel: 'unverified', tokenUsage: 'unknown' })) };
+        const approvalSnapshot = () => ({ policy: approved.policy, eventReceipt, eventScope, checkedAt: approved.checkedAt });
+        const preferred = (0, resolve_1.resolveEventWithFallback)({ role: 'implementer', requestedProfile: 'mechanical', policy: approved.policy,
+            receipt: eventReceipt, scope: eventScope, now: approved.checkedAt });
+        if (preferred.state !== 'resolved')
+            throw new Error('preferred selection should be enrolled');
+        const firstEnvelope = { ...routing_approval_1.routingEnvelope, outcome: preferred.outcome, unavailableEvidence: preferred.unavailableEvidence, capabilityDigest: preferred.capabilityDigest };
+        const first = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: firstEnvelope,
+            fingerprint: 'e'.repeat(64), approval: approvalSnapshot }, '2026-09-17T12:00:00.000Z');
+        expect(first.state.routingAttempts?.[0]).toMatchObject({ nativeEvidenceRequired: true, reservedAt: '2026-09-17T12:00:00.000Z' });
+        const rejected = (0, journal_1.observeRoutingAttempt)(first.state, { attemptId: first.attemptId, nativeAgentId: 'native-1', unavailableReason: 'PROVIDER_REJECTED' }, '2026-09-17T12:01:00.000Z');
+        const fallback = (0, resolve_1.resolveEventWithFallback)({ role: 'implementer', requestedProfile: 'mechanical', policy: approved.policy,
+            receipt: eventReceipt, scope: eventScope, now: approved.checkedAt, circuitReason: 'PROVIDER_REJECTED' });
+        if (fallback.state !== 'resolved')
+            throw new Error('full capability should be enrolled');
+        const fullEnvelope = { ...firstEnvelope, effectiveProfile: 'full', resolved: fallback.selection, outcome: fallback.outcome,
+            unavailableEvidence: fallback.unavailableEvidence, capabilityDigest: fallback.capabilityDigest };
+        const second = (0, journal_1.reserveRoutingAttempt)(rejected, { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: fullEnvelope,
+            fingerprint: 'f'.repeat(64), approval: approvalSnapshot }, '2026-09-17T12:02:00.000Z');
+        expect(second.state.routingAttempts?.map(item => item.state)).toEqual(['blocked', 'reserved']);
+        expect((0, journal_1.routingReport)(second.state)).toMatchObject({ fallbacks: 1, incidents: [expect.objectContaining({ reasonCode: 'PROVIDER_REJECTED', affectedObligations: 1, fallbackCount: 1, blockedCount: 1 })] });
+    });
     it('reserves an initial mechanical attempt at its approved explicit high effort', () => {
         const high = { ...routing_approval_1.routingEnvelope, resolved: { ...routing_approval_1.routingEnvelope.resolved, effort: { kind: 'explicit', value: 'high' } } };
         expect(() => (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: high, fingerprint: 'e'.repeat(64) }, '2026-09-17T00:00:00.000Z')).toThrow(/approval/i);
@@ -65,7 +134,30 @@ describe('routing journal helpers', () => {
     });
     it('reports routing attempts without envelope bodies or native identities', () => {
         const state = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: routing_approval_1.routingEnvelope, fingerprint: 'e'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z').state;
-        expect((0, journal_1.routingReport)(state)).toEqual({ schema: 'routing-report/v1', attempts: 1, plannedByRole: { implementer: 1 }, actualByRole: {}, byState: { reserved: 1 }, retries: 0, fallbacks: 0, unavailable: {}, verdicts: {}, administrativeRepairs: 0 });
+        expect((0, journal_1.routingReport)(state)).toEqual({ schema: 'routing-report/v1', attempts: 1, plannedByRole: { implementer: 1 }, actualByRole: {}, selections: [{ role: 'implementer', configured: routing_approval_1.routingEnvelope.resolved, accepted: 'unknown', backendModel: 'unknown' }], byState: { reserved: 1 }, retries: 0, fallbacks: 0, unavailable: {}, verdicts: {}, administrativeRepairs: 0,
+            measurement: { configuredSelection: 'envelope-recorded', acceptedSelection: 'not-natively-reconciled', backendModel: 'unknown', tokenUsage: 'unknown', savings: 'unverified' } });
+    });
+    it('reports a sealed native reconciliation separately from backend identity and savings', () => {
+        const state = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: routing_approval_1.routingEnvelope,
+            fingerprint: 'e'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z').state;
+        state.routingAttempts[0].nativeEventDigest = 'f'.repeat(64);
+        state.routingAttempts[0].nativeAgentId = 'child-1';
+        state.routingAttempts[0].observed = routing_approval_1.routingEnvelope.resolved;
+        state.routingAttempts[0].state = 'active';
+        expect((0, journal_1.routingReport)(state)).toMatchObject({ nativeReconciledByRole: { implementer: 1 },
+            selections: [{ role: 'implementer', configured: routing_approval_1.routingEnvelope.resolved, accepted: routing_approval_1.routingEnvelope.resolved, backendModel: 'unknown' }],
+            measurement: { acceptedSelection: 'natively-reconciled', backendModel: 'unknown', tokenUsage: 'unknown', savings: 'unverified' } });
+    });
+    it('reports a provider-reported Claude model only after native reconciliation', () => {
+        const state = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'lineage:S1', envelope: routing_approval_1.routingEnvelope,
+            fingerprint: 'e'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z').state;
+        state.routingAttempts[0].nativeEventDigest = 'f'.repeat(64);
+        state.routingAttempts[0].nativeAgentId = 'child-1';
+        state.routingAttempts[0].observed = routing_approval_1.routingEnvelope.resolved;
+        state.routingAttempts[0].observedBackendModel = 'claude-example-model';
+        state.routingAttempts[0].state = 'active';
+        expect((0, journal_1.routingReport)(state)).toMatchObject({ selections: [{ backendModel: 'claude-example-model' }],
+            measurement: { backendModel: 'provider-reported' } });
     });
     it('uses the exact deterministic implementation escalation sequence', () => {
         let state = (0, types_1.emptyState)('main');
@@ -81,6 +173,25 @@ describe('routing journal helpers', () => {
         state.routingAttempts[2].envelope = { ...state.routingAttempts[2].envelope, resolved: { selector: { kind: 'model', id: 'm' }, effort: { kind: 'explicit', value: 'high' } } };
         expect(() => (0, journal_1.resolveLineageEscalation)(state, 'l1', 'mechanical')).toThrow(/exhausted/i);
     });
+    it('returns the initial route for a native rejection so the full fallback can resolve', () => {
+        const state = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'l1', envelope: routing_approval_1.routingEnvelope,
+            fingerprint: '1'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z').state;
+        state.routingAttempts[0].state = 'blocked';
+        state.routingAttempts[0].verdict = 'inconclusive';
+        state.routingAttempts[0].reasonCode = 'PROVIDER_REJECTED';
+        expect((0, journal_1.resolveLineageEscalation)(state, 'l1', 'mechanical')).toEqual({ profile: 'mechanical', effort: 'medium' });
+        state.routingAttempts[0].envelope.effectiveProfile = 'full';
+        expect(() => (0, journal_1.resolveLineageEscalation)(state, 'l1', 'mechanical')).toThrow(/fallback|exhausted/i);
+    });
+    it('preserves Claude runtime-default effort across profile escalation', () => {
+        const state = (0, journal_1.reserveRoutingAttempt)((0, types_1.emptyState)('main'), { obligationId: 'impl:S1', lineageId: 'l1', envelope: routing_approval_1.routingEnvelope,
+            fingerprint: '1'.repeat(64), approval: routing_approval_1.routingApproval }, '2026-09-17T00:00:00.000Z').state;
+        state.implementationLineages[0].initialEffort = 'runtime-default';
+        state.routingAttempts[0].envelope.resolved.effort = { kind: 'runtime-default' };
+        state.routingAttempts[0].state = 'blocked';
+        state.routingAttempts[0].verdict = 'fail';
+        expect((0, journal_1.resolveLineageEscalation)(state, 'l1', 'mechanical')).toEqual({ profile: 'integration', effort: 'runtime-default' });
+    });
     it('rejects hostile roles and unavailable provenance before it can reach a report', () => {
         expect((0, types_1.isRoutingEnvelope)({ ...routing_approval_1.routingEnvelope, role: 'attacker-key' })).toBe(false);
         expect((0, types_1.isRoutingEnvelope)({ ...routing_approval_1.routingEnvelope, unavailableEvidence: ['secret=leak'] })).toBe(false);

package/dist/tests/core/model-policy/local-claude-scope.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const local_claude_scope_1 = require("../../../src/core/model-policy/local-claude-scope");
+describe('Claude local scope', () => {
+    const key = Buffer.alloc(32, 2);
+    const deps = {
+        readRoutingHookStatus: () => ({ state: 'absent' }),
+        readMachineKey: () => key,
+        queryClaudeAuthStatus: async () => ({ provenance: 'claude-auth-status', accountState: 'identified',
+            accountScopeDigest: 'a'.repeat(64), inferenceDispatched: false }),
+        queryRuntimeExecutable: async () => ({ version: '2.1.0', binaryDigest: 'b'.repeat(64), inferenceDispatched: false }),
+        readClaudeModelConfigDigest: () => 'c'.repeat(64),
+    };
+    it('assembles native account/runtime and local model config without inference', async () => {
+        await expect((0, local_claude_scope_1.queryLocalClaudeScope)('/tmp/project', 'native', deps)).resolves.toEqual({ state: 'current', scope: {
+                runtime: { target: 'claude-code', kind: 'native', version: '2.1.0', accountScopeDigest: 'a'.repeat(64) },
+                binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64),
+            } });
+    });
+    it('fails closed without machine key or stable account identity', async () => {
+        await expect((0, local_claude_scope_1.queryLocalClaudeScope)('/tmp/project', 'native', { ...deps, readMachineKey: () => null })).resolves.toEqual({ state: 'unverified', reason: 'MACHINE_KEY_MISSING' });
+        await expect((0, local_claude_scope_1.queryLocalClaudeScope)('/tmp/project', 'native', { ...deps, queryClaudeAuthStatus: async () => ({
+                provenance: 'claude-auth-status', accountState: 'unverified', accountScopeDigest: null, inferenceDispatched: false,
+            }) })).resolves.toEqual({ state: 'unverified', reason: 'ACCOUNT_UNVERIFIED' });
+    });
+    it('blocks dispatch after a hook failure while allowing a real native stop to recover', async () => {
+        const failed = { ...deps, readRoutingHookStatus: () => ({ state: 'failed', failures: [{ phase: 'stop', reasonCode: 'HOOK_TRANSCRIPT_UNVERIFIED', count: 1 }] }) };
+        await expect((0, local_claude_scope_1.queryLocalClaudeScope)('/tmp/project', 'native', failed)).resolves.toEqual({ state: 'unverified', reason: 'HOOK_CAPTURE_FAILED' });
+        await expect((0, local_claude_scope_1.queryLocalClaudeScope)('/tmp/project', 'native', { ...failed, requireHookHealthy: false })).resolves.toMatchObject({ state: 'current' });
+    });
+});

package/dist/tests/core/model-policy/machine-key.test.js

@@ -0,0 +1,38 @@
+"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 machine_key_1 = require("../../../src/core/model-policy/machine-key");
+describe('routing machine key', () => {
+    it('creates a stable private key only during explicit setup', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-machine-key-'));
+        try {
+            expect((0, machine_key_1.readMachineKey)(root)).toBeNull();
+            const first = (0, machine_key_1.ensureMachineKey)(root);
+            expect(first).toHaveLength(32);
+            expect((0, machine_key_1.ensureMachineKey)(root)).toEqual(first);
+            expect((0, machine_key_1.readMachineKey)(root)).toEqual(first);
+            if (process.platform !== 'win32')
+                expect(fs_1.default.statSync(path_1.default.join(root, 'routing-machine.key')).mode & 0o777).toBe(0o600);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('rejects a symlinked key without reading its target', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-machine-key-'));
+        const outside = path_1.default.join(root, 'outside');
+        fs_1.default.writeFileSync(outside, Buffer.alloc(32, 9));
+        fs_1.default.symlinkSync(outside, path_1.default.join(root, 'routing-machine.key'));
+        try {
+            expect(() => (0, machine_key_1.ensureMachineKey)(root)).toThrow(/symlink|unsafe/i);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/model-policy/native-claude-agent-definition.test.js

@@ -0,0 +1,31 @@
+"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 native_claude_agent_definition_1 = require("../../../src/core/model-policy/native-claude-agent-definition");
+describe('Claude custom-agent declared model', () => {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-agent-'));
+    const cwd = path_1.default.join(root, 'project');
+    const configDir = path_1.default.join(root, 'config');
+    const directory = path_1.default.join(configDir, 'agents');
+    beforeAll(() => { fs_1.default.mkdirSync(cwd); fs_1.default.mkdirSync(directory, { recursive: true }); });
+    afterAll(() => fs_1.default.rmSync(root, { recursive: true, force: true }));
+    afterEach(() => { for (const name of fs_1.default.readdirSync(directory))
+        fs_1.default.unlinkSync(path_1.default.join(directory, name)); });
+    it('requires an explicit full ID on the matching native agent type', () => {
+        fs_1.default.writeFileSync(path_1.default.join(directory, 'integration.md'), '---\nname: awm-integration\ndescription: work\nmodel: claude-sonnet-4-6\n---\n');
+        expect((0, native_claude_agent_definition_1.readClaudeAgentDeclaredModel)({ cwd, configDir, agentType: 'awm-integration' })).toEqual({ agentType: 'awm-integration', modelId: 'claude-sonnet-4-6' });
+        expect(() => (0, native_claude_agent_definition_1.readClaudeAgentDeclaredModel)({ cwd, configDir, agentType: 'awm-missing' })).toThrow(/no explicit custom definition/);
+    });
+    it('rejects aliases, inherit, duplicate definitions and unsafe paths', () => {
+        fs_1.default.writeFileSync(path_1.default.join(directory, 'integration.md'), '---\nname: awm-integration\ndescription: work\nmodel: sonnet\n---\n');
+        expect(() => (0, native_claude_agent_definition_1.readClaudeAgentDeclaredModel)({ cwd, configDir, agentType: 'awm-integration' })).toThrow(/full model ID/);
+        fs_1.default.writeFileSync(path_1.default.join(directory, 'integration.md'), '---\nname: awm-integration\ndescription: work\nmodel: claude-sonnet-4-6\n---\n');
+        fs_1.default.writeFileSync(path_1.default.join(directory, 'duplicate.md'), '---\nname: awm-integration\ndescription: work\nmodel: claude-sonnet-4-6\n---\n');
+        expect(() => (0, native_claude_agent_definition_1.readClaudeAgentDeclaredModel)({ cwd, configDir, agentType: 'awm-integration' })).toThrow(/ambiguous/);
+    });
+});

package/dist/tests/core/model-policy/native-claude-config.test.js

@@ -0,0 +1,53 @@
+"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 native_claude_config_1 = require("../../../src/core/model-policy/native-claude-config");
+describe('Claude local model config fingerprint', () => {
+    it('changes only when model-relevant settings change and never returns settings content', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-config-'));
+        const configDir = path_1.default.join(root, 'home');
+        const cwd = path_1.default.join(root, 'project');
+        fs_1.default.mkdirSync(configDir);
+        fs_1.default.mkdirSync(path_1.default.join(cwd, '.claude'), { recursive: true });
+        const settings = path_1.default.join(cwd, '.claude', 'settings.json');
+        fs_1.default.writeFileSync(settings, JSON.stringify({ model: 'claude-sonnet-4-6', permissions: { allow: ['Read'] } }));
+        const key = Buffer.alloc(32, 7);
+        try {
+            const first = (0, native_claude_config_1.readClaudeModelConfigDigest)({ cwd, configDir, key, environment: {} });
+            expect(first).toMatch(/^[a-f0-9]{64}$/);
+            fs_1.default.writeFileSync(settings, JSON.stringify({ model: 'claude-sonnet-4-6', permissions: { allow: ['Read', 'Edit'] } }));
+            expect((0, native_claude_config_1.readClaudeModelConfigDigest)({ cwd, configDir, key, environment: {} })).toBe(first);
+            fs_1.default.writeFileSync(settings, JSON.stringify({ model: 'claude-opus-4-7', permissions: { allow: ['Read', 'Edit'] } }));
+            expect((0, native_claude_config_1.readClaudeModelConfigDigest)({ cwd, configDir, key, environment: {} })).not.toBe(first);
+            const agents = path_1.default.join(cwd, '.claude', 'agents');
+            fs_1.default.mkdirSync(agents);
+            const beforeAgent = (0, native_claude_config_1.readClaudeModelConfigDigest)({ cwd, configDir, key, environment: {} });
+            fs_1.default.writeFileSync(path_1.default.join(agents, 'reviewer.md'), '---\nmodel: claude-sonnet-4-6\n---\n');
+            expect((0, native_claude_config_1.readClaudeModelConfigDigest)({ cwd, configDir, key, environment: {} })).not.toBe(beforeAgent);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('rejects a symlinked settings file', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-config-'));
+        const configDir = path_1.default.join(root, 'home');
+        const cwd = path_1.default.join(root, 'project');
+        fs_1.default.mkdirSync(configDir);
+        fs_1.default.mkdirSync(path_1.default.join(cwd, '.claude'), { recursive: true });
+        const outside = path_1.default.join(root, 'outside.json');
+        fs_1.default.writeFileSync(outside, '{}');
+        fs_1.default.symlinkSync(outside, path_1.default.join(cwd, '.claude', 'settings.json'));
+        try {
+            expect(() => (0, native_claude_config_1.readClaudeModelConfigDigest)({ cwd, configDir, key: Buffer.alloc(32, 7), environment: {} })).toThrow(/symlink|unsafe/i);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/model-policy/native-claude-machine.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_claude_machine_1 = require("../../../src/core/model-policy/native-claude-machine");
+describe('Claude Code read-only account discovery', () => {
+    const key = Buffer.alloc(32, 7);
+    it('HMACs a logged-in identity without returning the email or starting a model', async () => {
+        const response = { loggedIn: true, authMethod: 'claude.ai', apiProvider: 'firstParty', email: 'owner@example.test', orgId: 'org-1', subscriptionType: 'max' };
+        const script = `process.stdout.write(${JSON.stringify(JSON.stringify(response))})`;
+        const facts = await (0, native_claude_machine_1.queryClaudeAuthStatus)({ command: process.execPath, args: ['-e', script], timeoutMs: 5000, key });
+        expect(facts).toMatchObject({ provenance: 'claude-auth-status', accountState: 'identified', inferenceDispatched: false });
+        expect(facts.accountScopeDigest).toMatch(/^[a-f0-9]{64}$/);
+        expect(JSON.stringify(facts)).not.toContain(response.email);
+    });
+    it('keeps missing account fields unverified instead of inventing a scope', async () => {
+        const script = `process.stdout.write('${JSON.stringify({ loggedIn: true, authMethod: 'apiKey', apiProvider: 'firstParty' })}')`;
+        expect(await (0, native_claude_machine_1.queryClaudeAuthStatus)({ command: process.execPath, args: ['-e', script], timeoutMs: 5000, key })).toMatchObject({ accountState: 'unverified', accountScopeDigest: null });
+    });
+});

package/dist/tests/core/model-policy/native-claude-transcript.test.js

@@ -0,0 +1,45 @@
+"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 native_claude_transcript_1 = require("../../../src/core/model-policy/native-claude-transcript");
+describe('Claude Code native subagent transcript', () => {
+    it('extracts one actual model and timestamp without returning transcript content or inventing usage', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-transcript-'));
+        const file = path_1.default.join(root, 'projects', 'project-1', 'session-1', 'subagents', 'agent-agent-1.jsonl');
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        fs_1.default.writeFileSync(file, [
+            { type: 'assistant', timestamp: '2026-09-23T22:00:00.000Z', message: { model: 'claude-sonnet-4-6', content: [{ type: 'text', text: 'private prompt content' }], usage: { input_tokens: 10, output_tokens: 20 } } },
+            { type: 'assistant', timestamp: '2026-09-23T22:00:01.000Z', message: { model: 'claude-sonnet-4-6', content: [] } },
+        ].map(item => JSON.stringify(item)).join('\n'));
+        try {
+            const observed = (0, native_claude_transcript_1.readClaudeSubagentTranscript)({ configDir: root, file, agentId: 'agent-1' });
+            expect(observed).toMatchObject({ provenance: 'claude-subagent-transcript', actualModel: 'claude-sonnet-4-6', observedAt: '2026-09-23T22:00:01.000Z', tokenUsage: 'unknown' });
+            expect(JSON.stringify(observed)).not.toContain('private prompt content');
+            fs_1.default.writeFileSync(file, `${JSON.stringify({ type: 'assistant', timestamp: '2026-09-23T22:00:00.000Z', message: { model: 'claude-opus-4-7' } })}\n${JSON.stringify({ type: 'assistant', timestamp: '2026-09-23T22:00:01.000Z', message: { model: 'claude-sonnet-4-6' } })}`);
+            expect(() => (0, native_claude_transcript_1.readClaudeSubagentTranscript)({ configDir: root, file, agentId: 'agent-1' })).toThrow(/mixed|multiple/i);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('rejects symlinks and transcript files outside the native subagents tree', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-transcript-'));
+        const outside = path_1.default.join(root, 'outside.jsonl');
+        const linked = path_1.default.join(root, 'projects', 'p', 's', 'subagents', 'agent-agent-1.jsonl');
+        fs_1.default.mkdirSync(path_1.default.dirname(linked), { recursive: true });
+        fs_1.default.writeFileSync(outside, '{}');
+        fs_1.default.symlinkSync(outside, linked);
+        try {
+            expect(() => (0, native_claude_transcript_1.readClaudeSubagentTranscript)({ configDir: root, file: linked, agentId: 'agent-1' })).toThrow(/symlink|unsafe/i);
+            expect(() => (0, native_claude_transcript_1.readClaudeSubagentTranscript)({ configDir: root, file: outside, agentId: 'agent-1' })).toThrow(/outside|subagents/i);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/model-policy/native-claude.test.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_claude_1 = require("../../../src/core/model-policy/native-claude");
+describe('Claude native subagent lifecycle', () => {
+    const start = { hook_event_name: 'SubagentStart', session_id: 'session-1', agent_id: 'agent-1', agent_type: 'Explore' };
+    const stop = { hook_event_name: 'SubagentStop', session_id: 'session-1', agent_id: 'agent-1', agent_type: 'Explore', agent_transcript_path: '/tmp/agent-1.jsonl', stop_hook_active: false, last_assistant_message: 'done' };
+    it('links native hook identities without claiming a model or paid usage', () => {
+        expect((0, native_claude_1.normalizeClaudeSubagentLifecycle)(start, stop)).toEqual({
+            provenance: 'claude-code-subagent-hooks', sessionId: 'session-1', agentId: 'agent-1', agentType: 'Explore',
+            nativeDispatchVerified: true, acceptedSelectionVerified: false, actualModelVerified: false, tokenUsage: 'unknown',
+        });
+    });
+    it('rejects mismatched agent and session identities', () => {
+        expect(() => (0, native_claude_1.normalizeClaudeSubagentLifecycle)(start, { ...stop, agent_id: 'agent-2' })).toThrow(/identity/i);
+        expect(() => (0, native_claude_1.normalizeClaudeSubagentLifecycle)(start, { ...stop, session_id: 'session-2' })).toThrow(/identity/i);
+    });
+    it('rejects forged event kinds and missing transcript paths', () => {
+        expect(() => (0, native_claude_1.normalizeClaudeSubagentLifecycle)({ ...start, hook_event_name: 'Notification' }, stop)).toThrow(/hook/i);
+        expect(() => (0, native_claude_1.normalizeClaudeSubagentLifecycle)(start, { ...stop, agent_transcript_path: '' })).toThrow(/transcript/i);
+    });
+});

package/dist/tests/core/model-policy/native-codex-machine.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_codex_machine_1 = require("../../../src/core/model-policy/native-codex-machine");
+describe('Codex machine facts', () => {
+    it('hashes effective config and ChatGPT account scope without returning identifiers', async () => {
+        const server = `
+const readline = require('readline');
+const input = readline.createInterface({ input: process.stdin });
+input.on('line', line => {
+  const request = JSON.parse(line);
+  if (request.method === 'initialize') process.stdout.write(JSON.stringify({ id: request.id, result: {} }) + '\\n');
+  if (request.method === 'config/read') process.stdout.write(JSON.stringify({ id: request.id, result: { config: { model: 'gpt-6-sol', model_reasoning_effort: 'medium' }, origins: {} } }) + '\\n');
+  if (request.method === 'account/read') process.stdout.write(JSON.stringify({ id: request.id, result: { account: { type: 'chatgpt', email: 'secret@example.com', planType: 'pro' }, requiresOpenaiAuth: true } }) + '\\n');
+});`;
+        const input = { command: process.execPath, args: ['-e', server], timeoutMs: 5000, cwd: process.cwd(), key: Buffer.alloc(32, 7) };
+        const first = await (0, native_codex_machine_1.queryCodexMachineFacts)(input);
+        const second = await (0, native_codex_machine_1.queryCodexMachineFacts)(input);
+        expect(first).toEqual(second);
+        expect(first).toMatchObject({ provenance: 'codex-app-server-config-account', accountState: 'identified', configDigest: expect.stringMatching(/^[a-f0-9]{64}$/), accountScopeDigest: expect.stringMatching(/^[a-f0-9]{64}$/) });
+        expect(JSON.stringify(first)).not.toContain('secret@example.com');
+    });
+    it('keeps API-key account identity unverified instead of equating all keys', async () => {
+        const server = `
+const readline = require('readline');
+const input = readline.createInterface({ input: process.stdin });
+input.on('line', line => {
+  const request = JSON.parse(line);
+  if (request.method === 'initialize') process.stdout.write(JSON.stringify({ id: request.id, result: {} }) + '\\n');
+  if (request.method === 'config/read') process.stdout.write(JSON.stringify({ id: request.id, result: { config: {}, origins: {} } }) + '\\n');
+  if (request.method === 'account/read') process.stdout.write(JSON.stringify({ id: request.id, result: { account: { type: 'apiKey' }, requiresOpenaiAuth: true } }) + '\\n');
+});`;
+        await expect((0, native_codex_machine_1.queryCodexMachineFacts)({ command: process.execPath, args: ['-e', server], timeoutMs: 5000, cwd: process.cwd(), key: Buffer.alloc(32, 7) })).resolves.toMatchObject({ accountState: 'unverified', accountScopeDigest: null });
+    });
+});

package/dist/tests/core/model-policy/native-codex-rollout.test.js

@@ -0,0 +1,44 @@
+"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 native_codex_rollout_1 = require("../../../src/core/model-policy/native-codex-rollout");
+describe('Codex local rollout selection reader', () => {
+    const expected = { parentThreadId: 'parent-1', childThreadId: 'child-1', turnId: 'turn-1' };
+    const session = { type: 'session_meta', payload: { id: 'child-1', source: { subagent: { thread_spawn: { parent_thread_id: 'parent-1' } } }, cli_version: '0.156.1' } };
+    const turn = { timestamp: '2026-09-23T20:00:00.000Z', type: 'turn_context', payload: { turn_id: 'turn-1', model: 'gpt-6-luna', effort: 'high' } };
+    it('reads only an in-scope rollout and returns bounded per-turn metadata', () => {
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-codex-home-'));
+        const file = path_1.default.join(home, 'sessions', 'rollout.jsonl');
+        fs_1.default.mkdirSync(path_1.default.dirname(file));
+        fs_1.default.writeFileSync(file, `${JSON.stringify(session)}\n${JSON.stringify({ type: 'event_msg', payload: { private: 'do not return' } })}\n${JSON.stringify(turn)}\n`);
+        try {
+            expect((0, native_codex_rollout_1.readCodexRolloutSelection)({ codexHome: home, file, expected })).toMatchObject({
+                configuredSelection: { selector: { id: 'gpt-6-luna' }, effort: { value: 'high' } }, actualModelVerified: false,
+            });
+            expect(JSON.stringify((0, native_codex_rollout_1.readCodexRolloutSelection)({ codexHome: home, file, expected }))).not.toContain('private');
+        }
+        finally {
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
+    it('rejects a symlinked rollout and a path outside Codex sessions', () => {
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-codex-home-'));
+        const outside = path_1.default.join(home, 'outside.jsonl');
+        const linked = path_1.default.join(home, 'sessions', 'linked.jsonl');
+        fs_1.default.mkdirSync(path_1.default.dirname(linked));
+        fs_1.default.writeFileSync(outside, `${JSON.stringify(session)}\n${JSON.stringify(turn)}\n`);
+        fs_1.default.symlinkSync(outside, linked);
+        try {
+            expect(() => (0, native_codex_rollout_1.readCodexRolloutSelection)({ codexHome: home, file: linked, expected })).toThrow(/symlink|unsafe/i);
+            expect(() => (0, native_codex_rollout_1.readCodexRolloutSelection)({ codexHome: home, file: outside, expected })).toThrow(/outside|sessions/i);
+        }
+        finally {
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
+});