agentic-workflow-manager 9.11.12 → 9.12.1

package/dist/tests/commands/watch/request-recovery.test.js

@@ -0,0 +1,253 @@
+"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/journal/store");
+const requests_1 = require("../../../src/core/journal/requests");
+const apply_1 = require("../../../src/commands/watch/apply");
+const gate_1 = require("../../../src/commands/job/gate");
+const paths_1 = require("../../../src/core/journal/paths");
+const lock_1 = require("../../../src/commands/watch/lock");
+const request_recovery_1 = require("../../../src/commands/watch/request-recovery");
+const supervisor_1 = require("../../../src/commands/watch/supervisor");
+const archive_unused_1 = require("../../../src/commands/watch/archive-unused");
+const generations_1 = require("../../../src/commands/watch/generations");
+describe('issue #194: recovery of a rejected task request', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-recover-request-'));
+        (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'rama'], { cwd: repo });
+        (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', 'commit', '--allow-empty', '-qm', 'seed'], { cwd: repo });
+        (0, store_1.initJournal)(repo, 'rama');
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.schema = 2;
+        state.planBinding = {
+            path: 'docs/plans/cycle.md', digest: 'a'.repeat(64), schema: 'compact-slices/v1',
+            executionMode: 'desatendido', boundAt: new Date().toISOString(),
+        };
+        state.requiredVerifiers = ['test', 'sensors'];
+        state.generations.push({ n: 1, token: 'g1', state: 'active', launchedAt: new Date().toISOString() });
+        state.cycle.status = 'BLOCKED';
+        state.cycle.blockedReason = 'recovery no autorizado: hay conflictos durables de requests';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+    });
+    afterEach(() => fs_1.default.rmSync(repo, { recursive: true, force: true }));
+    function rejectedTask() {
+        const rejected = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'bad-task',
+            payload: { entity: 'task', taskId: 'S1', title: 'slice', verificationPlan: [{ id: 'test-s1', kind: 'test' }], reviewObligations: [] },
+        });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${rejected.file}.rejected`)).toBe(true);
+        expect(fs_1.default.readFileSync((0, paths_1.eventsPath)(repo, 'rama'), 'utf8')).toMatch(/request-rejected-invalid/);
+        return rejected;
+    }
+    function correctedTask(taskId = 'S1', kinds = ['test', 'sensors']) {
+        return (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: `corrected-${taskId}-${kinds.join('-')}`,
+            payload: { entity: 'task', taskId, title: 'slice', verificationPlan: kinds.map(kind => ({ id: `${kind}-${taskId}`, kind })), reviewObligations: [] },
+        });
+    }
+    test('rejection → corrected request → audited recovery → next action remains gated by real work', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        expect((0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'rama').state, false, () => null).reasons.some(reason => reason.category === 'request-problem')).toBe(true);
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', {
+            rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido plan de verificación', resume: true,
+        });
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tasks.map(task => task.id)).toEqual(['S1']);
+        expect(state.appliedRequests[replacement.requestId]).toMatchObject({ outcome: 'applied', resultRef: 'S1' });
+        expect(state.requestProblems[0]).toMatchObject({ kind: 'rejected', resolution: { replacementRequestId: replacement.requestId, generationToken: 'g1', reason: 'corregido plan de verificación' } });
+        expect(state.cycle.status).toBe('IN_PROGRESS');
+        expect(state.custodyDecisions).toEqual([expect.objectContaining({ decision: 'resume', generationToken: 'g1' })]);
+        expect(fs_1.default.existsSync(`${rejected.file}.rejected`)).toBe(true);
+        expect(fs_1.default.existsSync(replacement.file)).toBe(false);
+        expect(fs_1.default.readFileSync((0, paths_1.eventsPath)(repo, 'rama'), 'utf8')).toMatch(/request-recovered/);
+        const gate = (0, gate_1.computeGate)(state, false, () => null);
+        expect(gate.reasons.some(reason => reason.category === 'request-problem')).toBe(false);
+        expect(gate.pass).toBe(false);
+        expect(gate.reasons.some(reason => reason.category === 'pending-task')).toBe(true);
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', {
+            rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido plan de verificación', resume: true,
+        });
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(1);
+        // Crash after state publication but before queue cleanup: supervisor
+        // replay consumes the same request ID without registering S1 twice.
+        fs_1.default.writeFileSync(replacement.file, JSON.stringify({ requestId: replacement.requestId,
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'corrected-S1-test-sensors',
+            payload: { entity: 'task', taskId: 'S1', title: 'slice', verificationPlan: [
+                    { id: 'test-S1', kind: 'test' }, { id: 'sensors-S1', kind: 'sensors' }
+                ], reviewObligations: [] } }));
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(1);
+    });
+    test('wrong task and still-invalid correction leave rejection active without partial writes', () => {
+        const rejected = rejectedTask();
+        const wrong = correctedTask('S2');
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId, replacementRequestId: wrong.requestId, generationToken: 'g1', reason: 'wrong task', resume: true })).toThrow(/mismo taskId/);
+        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems[0].resolution).toBeUndefined();
+        fs_1.default.rmSync(wrong.file);
+        const invalid = correctedTask('S1', ['test']);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId, replacementRequestId: invalid.requestId, generationToken: 'g1', reason: 'still invalid', resume: true })).toThrow(/sensors/);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tasks).toHaveLength(0);
+        expect(state.requestProblems[0].resolution).toBeUndefined();
+        expect(state.cycle.status).toBe('BLOCKED');
+    });
+    test('stale generation, missing archive, and live supervisor lock cannot resolve a rejection', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const input = { rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido', resume: true };
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { ...input, generationToken: 'g0' })).toThrow(/generation/);
+        const lock = (0, lock_1.acquireLock)(repo);
+        try {
+            expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', input)).toThrow(/supervisor activo/);
+        }
+        finally {
+            (0, lock_1.releaseLock)(repo, lock);
+        }
+        fs_1.default.renameSync(`${rejected.file}.rejected`, `${rejected.file}.held`);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', input)).toThrow();
+        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems[0].resolution).toBeUndefined();
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(0);
+    });
+    test('an unrelated active problem prevents --resume and leaves the correction queued', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems.push({ file: path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'other.json'), kind: 'corrupt', detail: 'bad envelope', at: new Date().toISOString() });
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId,
+            replacementRequestId: replacement.requestId, generationToken: 'g1', reason: 'corregido', resume: true })).toThrow(/todas las requests/);
+        expect(fs_1.default.existsSync(replacement.file)).toBe(true);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(0);
+    });
+    test('a resolution-shaped state without an applied replacement is still an active gate problem', () => {
+        rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems[0].resolution = { replacementRequestId: 'req-1-0000000000-deadbeef', replacementPayloadDigest: 'a'.repeat(64), reason: 'forged', generationToken: 'g1', at: new Date().toISOString() };
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'rama').state, false, () => null).reasons.some(reason => reason.category === 'request-problem')).toBe(true);
+    });
+    test('an unrelated applied task cannot be cited as the replacement of S1', () => {
+        rejectedTask();
+        const unrelated = correctedTask('S2');
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems[0].resolution = { replacementRequestId: unrelated.requestId, replacementPayloadDigest: state.appliedRequests[unrelated.requestId].payloadDigest, reason: 'wrong link', generationToken: 'g1', at: new Date().toISOString() };
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'rama').state, false, () => null).reasons.some(reason => reason.category === 'request-problem')).toBe(true);
+    });
+    test('a corrupt request cannot be laundered through a task-shaped resolution', () => {
+        const replacement = correctedTask('S1');
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems.push({ file: path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'req-1-0000000000-deadbeef.json'),
+            kind: 'corrupt', detail: 'bad JSON', at: new Date().toISOString(), requestId: 'req-1-0000000000-deadbeef',
+            taskId: 'S1', generationToken: 'g1', resolution: { replacementRequestId: replacement.requestId,
+                replacementPayloadDigest: state.appliedRequests[replacement.requestId].payloadDigest,
+                reason: 'forged', generationToken: 'g1', at: new Date().toISOString() } });
+        expect(() => (0, store_1.writeJournal)(repo, 'rama', state)).toThrow(/forma invalida/);
+    });
+    test('resume rejects a different custody cause even if its text mentions requests', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.cycle.blockedReason = 'other failure; also mentions conflictos durables de requests';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId,
+            replacementRequestId: replacement.requestId, generationToken: 'g1', reason: 'corrected', resume: true })).toThrow(/custodia BLOCKED por requests/);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(0);
+    });
+    test('a blocked request remains the specific custody cause across supervisor ticks', () => {
+        rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect((0, supervisor_1.recoveryWhitelistBlocker)(state)).toBe('hay conflictos durables de requests');
+    });
+    test('an independent custody cause is never overwritten by an active request problem', () => {
+        rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.cycle.blockedReason = 'veredicto de sensores no concluyente';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, supervisor_1.recoveryWhitelistBlocker)((0, store_1.readJournal)(repo, 'rama').state)).toBe('el ciclo está bloqueado');
+    });
+    test('public journal status exposes the latest generation token after supervisor shutdown', () => {
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.generations[0].state = 'terminated';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, archive_unused_1.watchJournalStatus)(repo, 'rama')).toMatchObject({ latestGeneration: { n: 1, token: 'g1', state: 'terminated' } });
+    });
+    test('recovery without resume remains eligible for a later explicit resume', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const input = { rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido', resume: false };
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', input);
+        const blocker = (0, supervisor_1.recoveryWhitelistBlocker)((0, store_1.readJournal)(repo, 'rama').state);
+        (0, generations_1.enterCustody)(repo, 'rama', `recovery no autorizado: ${blocker}`);
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { ...input, resume: true });
+        expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('IN_PROGRESS');
+    });
+    test('a correction from a newer generation cannot silently resolve the archived rejection', () => {
+        const rejected = rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.generations[0].state = 'superseded';
+        state.generations.push({ n: 2, token: 'g2', state: 'active', launchedAt: new Date().toISOString() });
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        const replacement = (0, requests_1.emitRequest)(repo, 'rama', { kind: 'register-entity', generationToken: 'g2', idempotencyKey: 'corrected-g2',
+            payload: { entity: 'task', taskId: 'S1', verificationPlan: [{ id: 't2', kind: 'test' }, { id: 's2', kind: 'sensors' }], reviewObligations: [] } });
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId,
+            replacementRequestId: replacement.requestId, generationToken: 'g2', reason: 'different generation', resume: true })).toThrow(/generation/);
+        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems[0].resolution).toBeUndefined();
+    });
+    test('public watch recover-request command applies the correction under custody', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const cli = path_1.default.resolve(__dirname, '../../../src/index.ts');
+        const tsNode = require.resolve('ts-node/dist/bin.js');
+        const output = (0, child_process_1.execFileSync)(process.execPath, [tsNode, '--compiler-options', '{"module":"CommonJS"}', cli, 'watch', 'recover-request',
+            '--rejected', rejected.requestId, '--replacement', replacement.requestId,
+            '--generation', 'g1', '--reason', 'operador verificó reemplazo', '--resume'], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        expect(JSON.parse(output)).toMatchObject({ recovered: true, replacementRequestId: replacement.requestId });
+        expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('IN_PROGRESS');
+    });
+    test('job register rejects missing sensors before writing a request file', () => {
+        const cli = path_1.default.resolve(__dirname, '../../../src/index.ts');
+        const tsNode = require.resolve('ts-node/dist/bin.js');
+        const payload = JSON.stringify({ taskId: 'S1', verificationPlan: [{ id: 't1', kind: 'test' }], reviewObligations: [] });
+        let diagnostic = '';
+        try {
+            (0, child_process_1.execFileSync)(process.execPath, [tsNode, '--compiler-options', '{"module":"CommonJS"}', cli,
+                'job', 'register', '--generation', 'g1', '--entity', 'task', '--json', payload], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (error) {
+            diagnostic = String(error.stderr ?? '');
+        }
+        expect(diagnostic).toMatch(/verificationPlan.*sensors/);
+        expect(fs_1.default.readdirSync((0, paths_1.requestsDir)(repo, 'rama')).filter(name => name.endsWith('.json'))).toHaveLength(0);
+    });
+    test('JSON cannot override --entity to bypass task prevalidation', () => {
+        const cli = path_1.default.resolve(__dirname, '../../../src/index.ts');
+        const tsNode = require.resolve('ts-node/dist/bin.js');
+        const payload = JSON.stringify({ entity: 'task', taskId: 'S1', verificationPlan: [{ id: 't1', kind: 'test' }], reviewObligations: [] });
+        let diagnostic = '';
+        try {
+            (0, child_process_1.execFileSync)(process.execPath, [tsNode, '--compiler-options', '{"module":"CommonJS"}', cli,
+                'job', 'register', '--generation', 'g1', '--entity', 'cycle-plan', '--json', payload], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (error) {
+            diagnostic = String(error.stderr ?? '');
+        }
+        expect(diagnostic).toMatch(/entity.*coincidir/);
+        expect(fs_1.default.readdirSync((0, paths_1.requestsDir)(repo, 'rama')).filter(name => name.endsWith('.json'))).toHaveLength(0);
+    });
+});

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

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

package/dist/tests/core/model-policy/capabilities-v2.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const capabilities_v2_1 = require("../../../src/core/model-policy/capabilities-v2");
+const digestA = 'a'.repeat(64);
+const digestB = 'b'.repeat(64);
+const digestC = 'c'.repeat(64);
+const selection = (id) => ({ selector: { kind: 'model', id }, effort: { kind: 'explicit', value: 'high' } });
+const receipt = () => ({
+    schema: 'routing-capabilities/v2',
+    runtime: { target: 'codex', kind: 'native', version: '0.156.1', accountScopeDigest: digestA },
+    binaryDigest: digestB, configDigest: digestC, recordedAt: '2026-09-23T00:00:00.000Z',
+    claims: [
+        { selection: selection('gpt-6-luna'), mappingDigest: digestA, eventDigest: digestB, source: 'codex-turn-context', observedAt: '2026-09-23T00:00:00.000Z', actualModel: 'unverified', tokenUsage: 'unknown' },
+        { selection: selection('gpt-6-astra'), mappingDigest: digestB, eventDigest: digestC, source: 'codex-turn-context', observedAt: '2026-09-23T00:00:00.000Z', actualModel: 'unverified', tokenUsage: 'unknown' },
+    ],
+});
+describe('event-scoped routing capabilities v2', () => {
+    const scope = { runtime: receipt().runtime, binaryDigest: digestB, configDigest: digestC };
+    const later = new Date('2026-09-24T01:00:00.000Z');
+    it('keeps an unchanged native claim current after 25 hours without renewal', () => {
+        expect((0, capabilities_v2_1.validateEventReceipt)(receipt())).toMatchObject({ schema: 'routing-capabilities/v2' });
+        expect((0, capabilities_v2_1.evaluateEventReceipt)(receipt(), scope, selection('gpt-6-luna'), digestA, later)).toEqual({ state: 'current' });
+    });
+    it('invalidates only a changed selection mapping, not its neighbor', () => {
+        expect((0, capabilities_v2_1.evaluateEventReceipt)(receipt(), scope, selection('gpt-6-luna'), digestC, later)).toEqual({ state: 'drift', reason: 'POLICY_DRIFT' });
+        expect((0, capabilities_v2_1.evaluateEventReceipt)(receipt(), scope, selection('gpt-6-astra'), digestB, later)).toEqual({ state: 'current' });
+    });
+    it('fails closed on runtime, account, binary and config drift', () => {
+        const value = receipt();
+        expect((0, capabilities_v2_1.evaluateEventReceipt)(value, { ...scope, runtime: { ...scope.runtime, version: '0.157.0' } }, selection('gpt-6-luna'), digestA, later)).toEqual({ state: 'drift', reason: 'RUNTIME_DRIFT' });
+        expect((0, capabilities_v2_1.evaluateEventReceipt)(value, { ...scope, runtime: { ...scope.runtime, accountScopeDigest: digestB } }, selection('gpt-6-luna'), digestA, later)).toEqual({ state: 'drift', reason: 'ACCOUNT_DRIFT' });
+        expect((0, capabilities_v2_1.evaluateEventReceipt)(value, { ...scope, binaryDigest: digestC }, selection('gpt-6-luna'), digestA, later)).toEqual({ state: 'drift', reason: 'RUNTIME_DRIFT' });
+        expect((0, capabilities_v2_1.evaluateEventReceipt)(value, { ...scope, configDigest: digestB }, selection('gpt-6-luna'), digestA, later)).toEqual({ state: 'drift', reason: 'CONFIG_DRIFT' });
+    });
+    it('rejects malformed proof, duplicate claims, future records and missing scope', () => {
+        expect(() => (0, capabilities_v2_1.validateEventReceipt)({ ...receipt(), claims: [receipt().claims[0], receipt().claims[0]] })).toThrow(/duplicate/i);
+        expect(() => (0, capabilities_v2_1.validateEventReceipt)({ ...receipt(), claims: [{ ...receipt().claims[0], eventDigest: 'pretend' }] })).toThrow(/digest/i);
+        expect((0, capabilities_v2_1.evaluateEventReceipt)({ ...receipt(), recordedAt: '2026-09-25T00:00:00.000Z' }, scope, selection('gpt-6-luna'), digestA, later)).toEqual({ state: 'drift', reason: 'FUTURE_EVIDENCE' });
+        expect(() => (0, capabilities_v2_1.evaluateEventReceipt)(receipt(), { ...scope, configDigest: '' }, selection('gpt-6-luna'), digestA, later)).toThrow(/configDigest/i);
+        expect(() => (0, capabilities_v2_1.validateEventReceipt)({ ...receipt(), runtime: { ...receipt().runtime, target: 'antigravity' }, claims: [{ ...receipt().claims[0], source: 'claude-assistant-transcript' }] })).toThrow(/provider|target/i);
+    });
+});

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

@@ -0,0 +1,40 @@
+"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 claude_hook_events_1 = require("../../../src/core/model-policy/claude-hook-events");
+const machine_key_1 = require("../../../src/core/model-policy/machine-key");
+describe('sealed Claude hook pair', () => {
+    const start = { hook_event_name: 'SubagentStart', session_id: 'session-1', agent_id: 'agent-1', agent_type: 'plugin:reviewer' };
+    const stop = { hook_event_name: 'SubagentStop', session_id: 'session-1', agent_id: 'agent-1', agent_type: 'plugin:reviewer',
+        agent_transcript_path: '/tmp/agent-1.jsonl', stop_hook_active: false };
+    it('links start/stop without storing prompt text, rejects tampering and stale pending events', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-hook-'));
+        const previous = process.env.AWM_HOME;
+        process.env.AWM_HOME = root;
+        try {
+            (0, machine_key_1.ensureMachineKey)(root);
+            (0, claude_hook_events_1.recordClaudeHookStart)({ ...start, prompt: 'private prompt' }, new Date('2026-09-23T22:00:00.000Z'));
+            const file = path_1.default.join(root, 'claude-hook-starts', fs_1.default.readdirSync(path_1.default.join(root, 'claude-hook-starts'))[0]);
+            expect(fs_1.default.readFileSync(file, 'utf8')).not.toContain('private prompt');
+            const pair = (0, claude_hook_events_1.readClaudeHookPair)(stop, new Date('2026-09-23T22:01:00.000Z'));
+            expect(pair.lifecycle).toMatchObject({ sessionId: 'session-1', agentId: 'agent-1' });
+            expect(() => (0, claude_hook_events_1.readClaudeHookPair)(stop, new Date('2026-09-25T22:01:00.000Z'))).toThrow(/stale/i);
+            const envelope = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+            envelope.start.agent_type = 'other';
+            fs_1.default.writeFileSync(file, JSON.stringify(envelope));
+            expect(() => (0, claude_hook_events_1.readClaudeHookPair)(stop, new Date('2026-09-23T22:01:00.000Z'))).toThrow(/seal/i);
+        }
+        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/event-store-claude.test.js

@@ -0,0 +1,64 @@
+"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 event_store_1 = require("../../../src/core/model-policy/event-store");
+const machine_key_1 = require("../../../src/core/model-policy/machine-key");
+const native_claude_1 = require("../../../src/core/model-policy/native-claude");
+const native_claude_transcript_1 = require("../../../src/core/model-policy/native-claude-transcript");
+const native_claude_agent_definition_1 = require("../../../src/core/model-policy/native-claude-agent-definition");
+describe('Claude native event enrollment', () => {
+    it('binds a matching hook pair and transcript; keeps an unchanged claim beyond 24 hours', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-claude-event-'));
+        const previous = process.env.AWM_HOME;
+        process.env.AWM_HOME = root;
+        try {
+            (0, machine_key_1.ensureMachineKey)(root);
+            const configDir = path_1.default.join(root, 'claude');
+            const file = path_1.default.join(configDir, 'projects', 'p', 's', 'subagents', 'agent-agent-1.jsonl');
+            fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+            fs_1.default.writeFileSync(file, `${JSON.stringify({ type: 'assistant', timestamp: '2026-09-23T22:00:00.000Z', 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', 'worker.md'), '---\nname: awm-worker\ndescription: Test worker\nmodel: claude-sonnet-4-6\n---\n');
+            const start = { hook_event_name: 'SubagentStart', session_id: 'session-1', agent_id: 'agent-1', agent_type: 'awm-worker' };
+            const stop = { hook_event_name: 'SubagentStop', session_id: 'session-1', agent_id: 'agent-1', agent_type: 'awm-worker', agent_transcript_path: file, stop_hook_active: false };
+            const lifecycle = (0, native_claude_1.normalizeClaudeSubagentLifecycle)(start, stop);
+            const transcript = (0, native_claude_transcript_1.readClaudeSubagentTranscript)({ configDir, file, agentId: 'agent-1' });
+            const scope = { runtime: { target: 'claude-code', kind: 'native', version: '2.1.0', accountScopeDigest: 'a'.repeat(64) }, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+            const expectedSelection = { selector: { kind: 'model', id: 'claude-sonnet-4-6' }, effort: { kind: 'runtime-default' } };
+            const input = { scope, lifecycle, transcript, expectedSelection, mappingDigest: 'd'.repeat(64), now: new Date('2026-09-23T22:01:00.000Z') };
+            expect(() => (0, event_store_1.publishClaudeObservation)(input)).toThrow(/declared agent/i);
+            const declaredAgent = (0, native_claude_agent_definition_1.readClaudeAgentDeclaredModel)({ cwd: root, configDir, agentType: 'awm-worker' });
+            const enrolled = { ...input, declaredAgent };
+            const first = (0, event_store_1.publishClaudeObservation)(enrolled);
+            expect(first.claims[0]).toMatchObject({ actualModel: { id: 'claude-sonnet-4-6' }, tokenUsage: 'unknown' });
+            expect((0, event_store_1.publishClaudeObservation)({ ...enrolled, now: new Date('2026-09-25T00:00:00.000Z') })).toEqual(first);
+            expect((0, event_store_1.readStoredEventReceipt)(scope.runtime)).toEqual({ state: 'present', receipt: first });
+            expect(() => (0, event_store_1.publishClaudeObservation)({ ...enrolled, expectedSelection: { ...expectedSelection, selector: { kind: 'model', id: 'claude-opus-4-7' } } })).toThrow(/selection/i);
+            expect(() => (0, event_store_1.publishClaudeObservation)({ ...enrolled, expectedSelection: { ...expectedSelection, effort: { kind: 'explicit', value: 'high' } } })).toThrow(/selection|effort/i);
+            expect(() => (0, event_store_1.publishClaudeObservation)({ ...enrolled, lifecycle: { ...lifecycle } })).toThrow(/provenance/i);
+            expect(() => (0, event_store_1.publishClaudeObservation)({ ...enrolled, declaredAgent: { ...declaredAgent } })).toThrow(/declared agent/i);
+            const secondFile = path_1.default.join(configDir, 'projects', 'p', 's', 'subagents', 'agent-agent-2.jsonl');
+            fs_1.default.writeFileSync(secondFile, `${JSON.stringify({ type: 'assistant', timestamp: '2026-09-23T22:02:00.000Z', message: { model: 'claude-sonnet-4-6', content: [] } })}\n`);
+            const secondLifecycle = (0, native_claude_1.normalizeClaudeSubagentLifecycle)({ ...start, agent_id: 'agent-2' }, { ...stop, agent_id: 'agent-2', agent_transcript_path: secondFile });
+            const secondTranscript = (0, native_claude_transcript_1.readClaudeSubagentTranscript)({ configDir, file: secondFile, agentId: 'agent-2' });
+            const second = (0, event_store_1.publishClaudeObservation)({ ...enrolled, lifecycle: secondLifecycle, transcript: secondTranscript,
+                now: new Date('2026-09-23T22:03:00.000Z') });
+            expect(second.claims[0].nativeEvents).toEqual(expect.arrayContaining([
+                expect.objectContaining({ nativeAgentIdDigest: (0, event_store_1.claudeAgentIdDigest)('agent-1', (0, machine_key_1.ensureMachineKey)(root)) }),
+                expect.objectContaining({ nativeAgentIdDigest: (0, event_store_1.claudeAgentIdDigest)('agent-2', (0, machine_key_1.ensureMachineKey)(root)) }),
+            ]));
+        }
+        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/event-store.test.js

@@ -0,0 +1,151 @@
+"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 event_store_1 = require("../../../src/core/model-policy/event-store");
+const native_codex_1 = require("../../../src/core/model-policy/native-codex");
+const machine_key_1 = require("../../../src/core/model-policy/machine-key");
+const a = 'a'.repeat(64);
+const b = 'b'.repeat(64);
+const c = 'c'.repeat(64);
+const runtime = { target: 'codex', kind: 'native', version: '0.156.1', accountScopeDigest: a };
+const scope = { runtime, binaryDigest: b, configDigest: c };
+const observation = (id) => ({ provenance: 'codex-app-server-thread-read', parentThreadId: 'parent-1', childThreadId: `child-${id}`, turnId: `turn-${id}`, nativeDispatchVerified: true,
+    configuredSelection: { selector: { kind: 'model', id }, effort: { kind: 'explicit', value: 'high' } }, acceptedSelectionVerified: true, childRuntimeVersion: '0.156.1', actualModelVerified: false, tokenUsage: 'unknown' });
+const enrollment = (id, now, native = observation(id)) => ({ scope, observation: native, expectedSelection: observation(id).configuredSelection, mappingDigest: a, now });
+async function nativeObservation(id) {
+    const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-native-event-'));
+    const file = path_1.default.join(home, 'sessions', 'rollout.jsonl');
+    fs_1.default.mkdirSync(path_1.default.dirname(file));
+    fs_1.default.writeFileSync(file, [
+        { type: 'session_meta', payload: { id: `child-${id}`, source: { subagent: { thread_spawn: { parent_thread_id: 'parent-1' } } }, cli_version: '0.156.1' } },
+        { timestamp: '2026-09-23T00:59:00.000Z', type: 'turn_context', payload: { turn_id: `turn-${id}`, model: id, effort: 'high' } },
+    ].map(value => JSON.stringify(value)).join('\n'));
+    const response = { thread: { id: `child-${id}`, parentThreadId: 'parent-1', model: id, reasoningEffort: 'high', path: file,
+            turns: [{ id: `turn-${id}`, status: 'completed', items: [] }] } };
+    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 === 'thread/read') process.stdout.write(JSON.stringify({ id: request.id, result: ${JSON.stringify(response)} }) + '\\n');
+});`;
+    try {
+        return await (0, native_codex_1.queryCodexChildThreadObservation)({ command: process.execPath, args: ['-e', server], timeoutMs: 5000, parentThreadId: 'parent-1', childThreadId: `child-${id}`, codexHome: home });
+    }
+    finally {
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    }
+}
+describe('event-scoped capability store', () => {
+    it('publishes native claims once and preserves a second selection without renewal', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-event-store-'));
+        const previous = process.env.AWM_HOME;
+        process.env.AWM_HOME = root;
+        try {
+            expect((0, event_store_1.readStoredEventReceipt)(runtime)).toEqual({ state: 'absent' });
+            (0, machine_key_1.ensureMachineKey)(root);
+            const luna = await nativeObservation('gpt-6-luna');
+            const first = (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-23T01:00:00.000Z'), luna));
+            expect(first.claims).toHaveLength(1);
+            const file = path_1.default.join(root, 'routing-capabilities-v2', 'codex', 'native.json');
+            const before = fs_1.default.readFileSync(file);
+            (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-24T03:00:00.000Z'), luna));
+            expect(fs_1.default.readFileSync(file)).toEqual(before);
+            const second = (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-sol', new Date('2026-09-23T01:00:00.000Z'), await nativeObservation('gpt-6-sol')));
+            expect(second.claims).toHaveLength(2);
+            const read = (0, event_store_1.readStoredEventReceipt)(runtime);
+            expect(read.state).toBe('present');
+            if (read.state !== 'present')
+                throw new Error('expected a present receipt');
+            expect(read.receipt.claims.map(item => item.selection.selector.id)).toEqual(['gpt-6-luna', 'gpt-6-sol']);
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previous;
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('fails closed on a symlinked destination', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-event-store-'));
+        const previous = process.env.AWM_HOME;
+        process.env.AWM_HOME = root;
+        const file = path_1.default.join(root, 'routing-capabilities-v2', 'codex', 'native.json');
+        (0, machine_key_1.ensureMachineKey)(root);
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        const outside = path_1.default.join(root, 'outside.json');
+        fs_1.default.writeFileSync(outside, 'untouched');
+        fs_1.default.symlinkSync(outside, file);
+        try {
+            const native = await nativeObservation('gpt-6-luna');
+            expect(() => (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-23T01:00:00.000Z'), native))).toThrow(/symlink|unsafe/i);
+            expect(fs_1.default.readFileSync(outside, 'utf8')).toBe('untouched');
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previous;
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('refuses an unverified selection or a child from another runtime version', async () => {
+        const native = await nativeObservation('gpt-6-luna');
+        native.acceptedSelectionVerified = false;
+        expect(() => (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-23T01:00:00.000Z'), native))).toThrow(/native provenance/i);
+        native.acceptedSelectionVerified = true;
+        native.childRuntimeVersion = '0.156.0';
+        expect(() => (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-23T01:00:00.000Z'), native))).toThrow(/native provenance/i);
+    });
+    it('rejects a caller-authored accepted-looking observation without native provenance', () => {
+        expect(() => (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-23T01:00:00.000Z')))).toThrow(/native provenance/i);
+    });
+    it('rejects an old native turn for a new enrollment but retains an already stored claim after 25 hours', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-event-store-'));
+        const previous = process.env.AWM_HOME;
+        process.env.AWM_HOME = root;
+        try {
+            (0, machine_key_1.ensureMachineKey)(root);
+            const native = await nativeObservation('gpt-6-luna');
+            expect(() => (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-24T03:00:00.000Z'), native))).toThrow(/fresh/i);
+            const first = (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-23T01:00:00.000Z'), native));
+            const later = (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-24T03:00:00.000Z'), native));
+            expect(later).toEqual(first);
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previous;
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('rejects a forged on-disk claim even if its JSON shape and digests look valid', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-event-store-'));
+        const previous = process.env.AWM_HOME;
+        process.env.AWM_HOME = root;
+        try {
+            (0, machine_key_1.ensureMachineKey)(root);
+            (0, event_store_1.publishCodexObservation)(enrollment('gpt-6-luna', new Date('2026-09-23T01:00:00.000Z'), await nativeObservation('gpt-6-luna')));
+            const file = path_1.default.join(root, 'routing-capabilities-v2', 'codex', 'native.json');
+            const envelope = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+            envelope.receipt.claims[0].selection.selector.id = 'gpt-6-astra';
+            fs_1.default.writeFileSync(file, JSON.stringify(envelope));
+            expect((0, event_store_1.readStoredEventReceipt)(runtime)).toMatchObject({ 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 });
+        }
+    });
+});