agentic-workflow-manager 9.11.12 → 9.12.1

package/dist/src/core/model-policy/resolve.js

@@ -1,24 +1,100 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEventSelection = resolveEventSelection;
+exports.resolveEventWithFallback = resolveEventWithFallback;
 exports.resolveEscalatedSelection = resolveEscalatedSelection;
 exports.resolveDispatch = resolveDispatch;
 exports.resolveV1Dispatch = resolveV1Dispatch;
 exports.resolveSelection = resolveSelection;
+const crypto_1 = require("crypto");
 const capabilities_1 = require("./capabilities");
+const capabilities_v2_1 = require("./capabilities-v2");
+const selection_policy_digest_1 = require("./selection-policy-digest");
 const validate_1 = require("./validate");
 const validate_2 = require("../plan/validate");
+/** Event-scoped v2 evidence has no clock expiry. It is never converted into a
+ * v1 approval or promoted to backend-model proof. */
+function resolveEventSelection(input) {
+    if (!input || typeof input !== 'object' || !input.scope || !(input.now instanceof Date) || !Number.isFinite(input.now.getTime()))
+        throw new Error('event selection requires scope and finite clock');
+    if (!['implementer', 'specification-reviewer', 'code-quality-reviewer', 'final-reviewer', 'architecture', 'track-a-qa', 'track-b-qa', 'controller', 'documentation', 'retro', 'finishing'].includes(input.role))
+        throw new Error('event selection role is invalid');
+    if (!['mechanical', 'integration', 'judgment', 'full'].includes(input.requestedProfile))
+        throw new Error('event selection profile is invalid');
+    if (!input.policy)
+        return blocked('ROUTING_POLICY_ABSENT', 'An approved routing policy is required.');
+    if (!input.receipt)
+        return blocked('ROUTING_CAPABILITY_ABSENT', 'Native event enrollment is absent.');
+    let policy;
+    try {
+        policy = (0, validate_1.validateApprovedPolicy)(input.policy);
+    }
+    catch {
+        return blocked('ROUTING_POLICY_INVALID', 'Approved routing policy is corrupt.');
+    }
+    const mapping = policy.content.mappings.find(row => row.target === input.scope.runtime.target && row.runtimeKind === input.scope.runtime.kind);
+    if (!mapping)
+        return blocked('ROUTING_POLICY_MAPPING_ABSENT', 'Approved policy has no exact target/runtime mapping.');
+    const effectiveProfile = input.role === 'implementer' ? input.requestedProfile : 'full';
+    const wanted = effectiveProfile === 'full' ? mapping.fullCapability : mapping.profiles[effectiveProfile];
+    let receipt;
+    try {
+        receipt = (0, capabilities_v2_1.validateEventReceipt)(input.receipt);
+    }
+    catch {
+        return blocked('ROUTING_CAPABILITY_INVALID', 'Native event enrollment is corrupt.');
+    }
+    let currentness;
+    try {
+        currentness = (0, capabilities_v2_1.evaluateEventReceipt)(receipt, input.scope, wanted, (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, wanted), input.now);
+    }
+    catch {
+        return blocked('ROUTING_CAPABILITY_INVALID', 'Native event enrollment or scope is invalid.');
+    }
+    if (currentness.state === 'drift')
+        return blocked(`ROUTING_${currentness.reason}`, `Native event enrollment is not current: ${currentness.reason}.`);
+    const claim = receipt.claims.find(item => equal(item.selection, wanted));
+    if (!claim)
+        return blocked('ROUTING_SELECTION_UNENROLLED', 'Approved selection has no native event enrollment.');
+    if (input.scope.runtime.target === 'claude-code' && !claim.nativeAgentType)
+        return blocked('ROUTING_AGENT_TYPE_UNVERIFIED', 'Claude native agent type is not bound to the enrolled selection.');
+    if (claim.actualModel === 'unverified') {
+        if (!mapping.degradation.allowMissingObservedIdentity)
+            return blocked('ROUTING_OBSERVED_IDENTITY_UNAVAILABLE', 'Actual backend model is unverified and policy does not permit operational routing.');
+        return { state: 'resolved', selection: wanted, effectiveProfile, outcome: 'degraded', policyDigest: policy.contentDigest,
+            capabilityDigest: (0, crypto_1.createHash)('sha256').update(JSON.stringify(receipt)).digest('hex'), unavailableEvidence: ['observedModelEvidence'], ...(claim.nativeAgentType ? { nativeAgentType: claim.nativeAgentType } : {}) };
+    }
+    if (wanted.selector.kind !== 'model' || claim.actualModel.id !== wanted.selector.id)
+        return blocked('ROUTING_SELECTION_MISMATCH', 'Native backend model does not match the approved selection.');
+    return { state: 'resolved', selection: wanted, effectiveProfile, outcome: 'native', policyDigest: policy.contentDigest,
+        capabilityDigest: (0, crypto_1.createHash)('sha256').update(JSON.stringify(receipt)).digest('hex'), unavailableEvidence: [], ...(claim.nativeAgentType ? { nativeAgentType: claim.nativeAgentType } : {}) };
+}
+function resolveEventWithFallback(input) {
+    const preferred = resolveEventSelection(input);
+    if ((preferred.state === 'resolved' && !input.circuitReason) || input.role !== 'implementer' || input.requestedProfile === 'full')
+        return preferred;
+    const full = resolveEventSelection({ ...input, role: 'code-quality-reviewer', requestedProfile: 'full' });
+    const reason = input.circuitReason ?? (preferred.state === 'blocked' ? preferred.diagnostics[0].code : 'PROVENANCE_MISSING');
+    if (full.state === 'blocked')
+        return blocked('ROUTING_FALLBACK_UNAVAILABLE', `Optimized route ${reason} and full fallback ${full.diagnostics[0].code}; enroll the missing selection with awm model-policy setup.`);
+    return { ...full, effectiveProfile: 'full', outcome: 'degraded', fallbackReason: reason };
+}
 function resolveEscalatedSelection(input) {
-    if (!input || input.role !== 'implementer' || !['medium', 'high'].includes(input.expectedEffort))
+    if (!input || input.role !== 'implementer' || !['medium', 'high', 'runtime-default'].includes(input.expectedEffort))
         throw new Error('escalated selection requires an implementer and a supported effort');
-    const selected = resolveSelection(input);
+    const selected = resolveConfiguredSelection(input);
     if (selected.state === 'blocked')
         return selected;
+    if (selected.fallbackReason)
+        return selected;
     const effort = selected.selection.effort;
+    if (input.expectedEffort === 'runtime-default')
+        return effort.kind === 'runtime-default' ? selected : blocked('ROUTING_ESCALATION_EFFORT_UNAVAILABLE', 'The approved selected effort does not match runtime-default escalation.');
     if (input.requestedProfile !== 'judgment')
         return effort.kind === 'explicit' && effort.value === input.expectedEffort ? selected : blocked('ROUTING_ESCALATION_EFFORT_UNAVAILABLE', 'The approved selected effort does not match the next lineage escalation.');
     if (effort.kind === 'explicit' && effort.value === 'medium' && input.expectedEffort === 'medium')
         return selected;
-    const full = resolveSelection({ ...input, role: 'code-quality-reviewer', requestedProfile: 'full' });
+    const full = resolveConfiguredSelection({ ...input, role: 'code-quality-reviewer', requestedProfile: 'full' });
     if (full.state === 'blocked')
         return full;
     const sameModel = full.selection.selector.kind === selected.selection.selector.kind && full.selection.selector.id === selected.selection.selector.id;
@@ -30,6 +106,20 @@ function resolveEscalatedSelection(input) {
         return { ...full, effectiveProfile: 'judgment' };
     return blocked('ROUTING_ESCALATION_EFFORT_UNAVAILABLE', 'The approved selected effort does not match the next lineage escalation.');
 }
+function resolveConfiguredSelection(input) {
+    if (input.eventReceipt !== undefined || input.eventScope !== undefined) {
+        if (!input.eventReceipt || !input.eventScope)
+            return blocked('ROUTING_EVENT_SCOPE_MISSING', 'Event-scoped routing requires both a receipt and local scope.');
+        const mapping = input.policy?.content.mappings.find(item => item.target === input.eventScope?.runtime.target && item.runtimeKind === input.eventScope?.runtime.kind);
+        const wanted = mapping && input.role === 'implementer' && input.requestedProfile !== 'full' ? mapping.profiles[input.requestedProfile] : undefined;
+        const incident = wanted && input.circuitIncidents?.find(item => item.target === input.eventScope?.runtime.target
+            && equal(item.selection, wanted)
+            && ['PROVIDER_REJECTED', 'SELECTION_MISMATCH', 'PROVENANCE_MISSING'].includes(item.reasonCode));
+        const circuitReason = incident?.reasonCode;
+        return resolveEventWithFallback({ role: input.role, requestedProfile: input.requestedProfile, policy: input.policy, receipt: input.eventReceipt, scope: input.eventScope, now: input.now, circuitReason });
+    }
+    return resolveSelection(input);
+}
 /** Resolve only from the immutable validator report; a reopened plan may never
  * provide a routing profile after validation. */
 function resolveDispatch(input) {
@@ -49,14 +139,14 @@ function resolveDispatch(input) {
             throw new Error('local routing requires a valid slice');
         if (!local && input.sliceId !== undefined)
             throw new Error('slice is only valid for local routing');
-        return resolveSelection({ ...input, requestedProfile: 'full' });
+        return resolveConfiguredSelection({ ...input, requestedProfile: 'full' });
     }
     if (typeof input.sliceId !== 'string' || input.sliceId.length === 0)
         throw new Error('implementer routing requires a slice');
     const slice = input.plan.manifest.slices.find(candidate => candidate.id === input.sliceId);
     if (!slice)
         throw new Error('routing slice does not exist in the validated plan');
-    return resolveSelection({ ...input, requestedProfile: slice.implementerProfile });
+    return resolveConfiguredSelection({ ...input, requestedProfile: slice.implementerProfile });
 }
 function resolveV1Dispatch(input) {
     if (!input.plan || input.plan.schema !== 'compact-slices/v1')
@@ -64,7 +154,7 @@ function resolveV1Dispatch(input) {
     (0, validate_2.assertVerifiedValidPlanReport)(input.plan);
     if (!input.optInV1)
         return { state: 'not-required', reason: 'v1-without-opt-in' };
-    return resolveSelection({ ...input, requestedProfile: 'full' });
+    return resolveConfiguredSelection({ ...input, requestedProfile: 'full' });
 }
 function equal(left, right) { return left.selector.kind === right.selector.kind && left.selector.id === right.selector.id && left.effort.kind === right.effort.kind && (left.effort.kind !== 'explicit' || left.effort.value === right.effort.value); }
 function blocked(code, message) { return { state: 'blocked', diagnostics: [(0, capabilities_1.routingDiagnostic)(code, message)] }; }

package/dist/src/core/model-policy/selection-policy-digest.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectionPolicyDigest = selectionPolicyDigest;
+const crypto_1 = require("crypto");
+const validate_1 = require("./validate");
+function same(left, right) {
+    return left.selector.kind === right.selector.kind && left.selector.id === right.selector.id
+        && left.effort.kind === right.effort.kind
+        && (left.effort.kind !== 'explicit' || left.effort.value === right.effort.value);
+}
+/** This digest binds what native work proved: the selected model and effort.
+ * Degradation permission is evaluated at dispatch and may be approved later
+ * without forcing a second native run for the same selection. */
+function selectionPolicyDigest(mapping, selection) {
+    const validated = (0, validate_1.validatePolicyContent)({ schema: 'model-policy/v1', mappings: [mapping],
+        implementationBudget: { maxAttempts: 3, escalation: ['mechanical', 'integration', 'judgment'], judgmentEfforts: ['medium', 'high'] } }).mappings[0];
+    const requested = [validated.profiles.mechanical, validated.profiles.integration, validated.profiles.judgment, validated.fullCapability];
+    const found = requested.find(item => same(item, selection));
+    if (!found)
+        throw new Error('selection is not approved in this mapping');
+    return (0, crypto_1.createHash)('sha256').update(JSON.stringify({ target: validated.target, runtimeKind: validated.runtimeKind, selection: found })).digest('hex');
+}

package/dist/src/core/model-policy/setup-readiness.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routingSetupGuidance = routingSetupGuidance;
+const store_1 = require("./store");
+const capabilities_1 = require("./capabilities");
+const json_1 = require("../plan/json");
+const event_store_1 = require("./event-store");
+const capabilities_v2_1 = require("./capabilities-v2");
+const selection_policy_digest_1 = require("./selection-policy-digest");
+/** Local guidance only: no provider process, inference, approval or filesystem write. */
+function locallyCurrentReceipt(mapping, now) {
+    try {
+        const raw = (0, store_1.readBoundedCandidate)((0, capabilities_1.storedCapabilityPath)(mapping.target, mapping.runtimeKind));
+        if (raw === null)
+            return false;
+        const receipt = (0, capabilities_1.validateCapabilityReceipt)((0, json_1.parseJsonNoDuplicate)(raw));
+        const caps = receipt.capabilities;
+        return receipt.runtime.target === mapping.target && receipt.runtime.kind === mapping.runtimeKind
+            && (0, capabilities_1.receiptIsCurrent)(receipt, receipt.runtime, now)
+            && caps.nativeSubagents === 'supported' && caps.modelOverride === 'supported' && caps.effortOverride === 'supported'
+            && (caps.observedModelEvidence === 'supported' || mapping.degradation.allowMissingObservedIdentity);
+    }
+    catch {
+        return false;
+    }
+}
+/** Passive diagnostics can check sealed coverage, but only dispatch recomputes
+ * runtime/account/config fingerprints. No provider process runs here. */
+function locallyEnrolledEvent(mapping, now, reader) {
+    if (mapping.target !== 'codex' && mapping.target !== 'claude-code')
+        return 'absent';
+    try {
+        const stored = reader({ target: mapping.target, kind: mapping.runtimeKind, version: '0.0.0', accountScopeDigest: '0'.repeat(64) });
+        if (stored.state !== 'present')
+            return stored.state;
+        const receipt = stored.receipt;
+        if (receipt.runtime.target !== mapping.target || receipt.runtime.kind !== mapping.runtimeKind)
+            return 'uncovered';
+        const scope = { runtime: receipt.runtime, binaryDigest: receipt.binaryDigest, configDigest: receipt.configDigest };
+        const selections = [...Object.values(mapping.profiles), mapping.fullCapability];
+        return selections.every(selected => {
+            const current = (0, capabilities_v2_1.evaluateEventReceipt)(receipt, scope, selected, (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, selected), now);
+            if (current.state !== 'current')
+                return false;
+            const claim = receipt.claims.find(item => JSON.stringify(item.selection) === JSON.stringify(selected));
+            return claim !== undefined && (claim.actualModel !== 'unverified' || mapping.degradation.allowMissingObservedIdentity);
+        }) ? 'covered' : 'uncovered';
+    }
+    catch {
+        return 'invalid';
+    }
+}
+function routingSetupGuidance(policy, now = new Date(), deps = {}) {
+    if (!policy || typeof policy !== 'object' || !('state' in policy))
+        throw new Error('routing policy state is invalid');
+    if (!(now instanceof Date) || !Number.isFinite(now.getTime()))
+        throw new Error('routing setup clock must be finite');
+    if (policy.state === 'absent')
+        return [];
+    if (policy.state === 'invalid') {
+        if (typeof policy.reason !== 'string' || policy.reason.length === 0 || policy.reason.length > 4096)
+            throw new Error('routing policy invalid reason is malformed');
+        return [{ state: 'policy-invalid', reason: policy.reason }];
+    }
+    if (policy.state !== 'approved' || !policy.policy || !Array.isArray(policy.policy.content?.mappings))
+        throw new Error('approved routing policy state is malformed');
+    return policy.policy.content.mappings.flatMap(mapping => {
+        if (typeof mapping.target !== 'string' || typeof mapping.runtimeKind !== 'string' || !/^[a-z0-9][a-z0-9_-]{0,127}$/.test(mapping.runtimeKind))
+            throw new Error('routing policy mapping is malformed');
+        const event = locallyEnrolledEvent(mapping, now, deps.readStoredEventReceipt ?? event_store_1.readStoredEventReceipt);
+        if (event === 'covered')
+            return [{ target: mapping.target, runtimeKind: mapping.runtimeKind, state: 'coverage-only' }];
+        if (event === 'absent' && locallyCurrentReceipt(mapping, now))
+            return [];
+        return [{ target: mapping.target, runtimeKind: mapping.runtimeKind, state: 'needs-evidence', command: `awm model-policy setup --provider ${mapping.target} --json` }];
+    });
+}

package/dist/src/providers/index.js

@@ -53,10 +53,12 @@ const CONFIG_HOME = {
     // Una corrida del playbook en una maquina con CODEX_HOME seteado encontro el hook
     // instalado donde Codex no mira. Ver docs/decisions.md D-011.
     codex: { envVar: 'CODEX_HOME', dir: '.codex' },
+    // Claude Code documenta CLAUDE_CONFIG_DIR para mover toda su configuracion,
+    // incluidos settings.json y transcripciones de subagentes.
+    'claude-code': { envVar: 'CLAUDE_CONFIG_DIR', dir: '.claude' },
     // Los demas usan su directorio por defecto. `null` es una afirmacion honesta —
     // "no le conocemos override"— y no un "no tiene". Cuando se confirme uno contra su
     // binario, se cambia aca y el guard obliga a que todas sus rutas lo sigan.
-    'claude-code': { envVar: null, dir: '.claude' },
     opencode: { envVar: null, dir: '.config/opencode' },
     cursor: { envVar: null, dir: '.cursor' },
     copilot: { envVar: null, dir: '.github' },

package/dist/tests/commands/doctor-routing.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const doctor_1 = require("../../src/commands/doctor");
+describe('doctor routing setup', () => {
+    it('adds a pending, non-degrading machine configuration action only to the mapped provider', () => {
+        const report = {
+            overall: 'healthy', providers: [
+                { id: 'codex', label: 'Codex', tier: 'hooks-native', checks: [] },
+                { id: 'claude-code', label: 'Claude Code', tier: 'hooks-native', checks: [] },
+            ],
+        };
+        const updated = (0, doctor_1.attachRoutingSetupGuidance)(report, [
+            { target: 'codex', runtimeKind: 'native', state: 'needs-evidence', command: 'awm model-policy discover --provider codex --json' },
+        ]);
+        expect(updated.providers[0].checks).toEqual([
+            { id: 'routing.machine', state: 'pending', detail: 'native routing evidence not checked for native', remediationCode: 'awm model-policy discover --provider codex --json' },
+        ]);
+        expect(updated.providers[1].checks).toEqual([]);
+        expect(updated.overall).toBe('healthy');
+        expect(report.providers[0].checks).toEqual([]);
+    });
+});

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

@@ -39,6 +39,11 @@ describe('runDoctor legacy JSON fixtures', () => {
         }
     });
 });
+test('doctor labels sealed routing coverage as local-only without asking for recurring setup', () => {
+    const report = (0, doctor_1.attachRoutingSetupGuidance)({ overall: 'healthy', providers: [{ id: 'codex', label: 'Codex', tier: 'hooks-native', checks: [] }] }, [{ target: 'codex', runtimeKind: 'native', state: 'coverage-only' }]);
+    expect(report.providers[0].checks).toEqual([{ id: 'routing.machine', state: 'supported',
+            detail: 'sealed selection coverage for native only; current runtime/account/config scope is checked at routed dispatch' }]);
+});
 describe('runDoctor dashboard modes', () => {
     it('CLI rejects --html without an argument before collection or writes', async () => {
         const program = new commander_1.Command();

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

@@ -59,6 +59,10 @@ describe('installHook (happy path + merge)', () => {
         expect(settings.hooks.SessionStart).toHaveLength(1);
         expect(settings.hooks.SessionStart[0].matcher).toBe('startup|clear|compact');
         expect(settings.hooks.SessionStart[0].hooks[0].command).toContain('run-hook.cmd');
+        expect(settings.hooks.SubagentStart[0].hooks[0].command).toBe('awm model-policy hook-event --event start');
+        expect(settings.hooks.SubagentStop[0].hooks[0].command).toBe('awm model-policy hook-event --event stop');
+        expect(settings.hooks.SubagentStart[0].hooks[0].async).toBe(false);
+        expect(settings.hooks.SubagentStop[0].hooks[0].async).toBe(false);
         expect(result.backupPath).toBeNull();
     });
     it('merges with pre-existing SessionStart entry from another plugin', () => {
@@ -96,6 +100,8 @@ describe('installHook (happy path + merge)', () => {
         expect(result2.status).toBe('already-up-to-date');
         const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf-8'));
         expect(settings.hooks.SessionStart).toHaveLength(1);
+        expect(settings.hooks.SubagentStart).toHaveLength(1);
+        expect(settings.hooks.SubagentStop).toHaveLength(1);
     });
     it('replaces a stale AWM entry when paths change', () => {
         const claudeDir = path_1.default.join(tmpHome, '.claude');

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

@@ -66,6 +66,9 @@ describe('resyncInstalledHooks', () => {
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
         ]);
+        const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf8'));
+        expect(settings.hooks.SubagentStart[0].hooks[0].command).toBe('awm model-policy hook-event --event start');
+        expect(settings.hooks.SubagentStop[0].hooks[0].command).toBe('awm model-policy hook-event --event stop');
         const synced = fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8');
         expect(synced).toContain('NEW VERSION');
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(false);

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

@@ -42,7 +42,9 @@ describe('computeHookStatus', () => {
                 SessionStart: [{
                         matcher: 'startup|clear|compact',
                         hooks: [{ type: 'command', command: `${hooksDir}/run-hook.cmd session-start`, async: false }]
-                    }]
+                    }],
+                SubagentStart: [{ matcher: '.+', hooks: [{ type: 'command', command: 'awm model-policy hook-event --event start', async: false }] }],
+                SubagentStop: [{ matcher: '.+', hooks: [{ type: 'command', command: 'awm model-policy hook-event --event stop', async: false }] }]
             }
         }, null, 2));
     }
@@ -56,6 +58,15 @@ describe('computeHookStatus', () => {
         expect(result.checks.runHookWrapper.ok).toBe(true);
         expect(result.checks.settingsEntry.ok).toBe(true);
     });
+    it('does not certify a non-command routing hook with matching command text', () => {
+        setupInstalledHook();
+        const settings = path_1.default.join(tmpHome, '.claude/settings.json');
+        const parsed = JSON.parse(fs_1.default.readFileSync(settings, 'utf8'));
+        parsed.hooks.SubagentStart[0].hooks[0].type = 'prompt';
+        fs_1.default.writeFileSync(settings, JSON.stringify(parsed));
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        expect(computeHookStatus('claude-code').checks.routingCapture.ok).toBe(false);
+    });
     it('reports DEGRADED when bootstrap skill is missing', () => {
         setupInstalledHook();
         fs_1.default.unlinkSync(path_1.default.join(tmpHome, '.awm/hooks/using-awm.md'));

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 });
+        }
+    });
+});