agentic-workflow-manager 9.12.1 → 9.12.3

package/dist/tests/commands/watch/reopened-196.test.js

@@ -0,0 +1,749 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const apply_1 = require("../../../src/commands/watch/apply");
+const generations_1 = require("../../../src/commands/watch/generations");
+const types_1 = require("../../../src/core/journal/types");
+const store_1 = require("../../../src/core/journal/store");
+const requests_1 = require("../../../src/core/journal/requests");
+const request_1 = require("../../../src/commands/job/request");
+const init_1 = require("../../../src/commands/watch/init");
+const validate_1 = require("../../../src/core/plan/validate");
+const watch_1 = require("../../../src/commands/watch");
+const supervisor_1 = require("../../../src/commands/watch/supervisor");
+const supervisorModule = __importStar(require("../../../src/commands/watch/supervisor"));
+const generationModule = __importStar(require("../../../src/commands/watch/generations"));
+const adapterModule = __importStar(require("../../../src/core/journal/adapter"));
+const routing_approval_1 = require("../../helpers/routing-approval");
+const routing_approval_2 = require("../../helpers/routing-approval");
+const canonical_1 = require("../../../src/core/model-policy/canonical");
+const machine_key_1 = require("../../../src/core/model-policy/machine-key");
+const native_routing_proof_1 = require("../../../src/core/model-policy/native-routing-proof");
+const selection_policy_digest_1 = require("../../../src/core/model-policy/selection-policy-digest");
+const admission_recovery_1 = require("../../../src/commands/watch/admission-recovery");
+const eventStore = __importStar(require("../../../src/core/model-policy/event-store"));
+const localScope = __importStar(require("../../../src/core/model-policy/local-event-scope"));
+const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+const paths_1 = require("../../../src/core/journal/paths");
+const paths_2 = require("../../../src/core/journal/paths");
+function v2State() {
+    const state = (0, types_1.emptyState)('main');
+    state.schema = 2;
+    state.planBinding = {
+        path: 'plans/cycle.md', digest: routing_approval_1.routingEnvelope.planDigest,
+        executionDigest: routing_approval_1.routingEnvelope.executionDigest, executionIdentitySchema: 'awm-plan-execution/v1', schema: 'compact-slices/v2',
+        executionMode: 'desatendido', boundAt: new Date().toISOString(),
+    };
+    state.tasks.push({ id: 'S1', title: 'Implement S1', status: 'pending', attempts: 0,
+        verificationPlan: [], reviewObligations: [] });
+    state.routingAttempts = [{ schema: 'routing-attempt/v1', id: 'route-1', obligationId: 'S1-implementer',
+            lineageId: 'lineage-S1', attempt: 1, envelope: routing_approval_1.routingEnvelope,
+            envelopeDigest: 'e'.repeat(64), fingerprint: 'f'.repeat(64), state: 'reserved',
+            reservedAt: new Date().toISOString(), reservationRequestId: 'reserve-1', nativeEvidenceRequired: true }];
+    state.appliedRequests['reserve-1'] = { requestId: 'reserve-1', idempotencyKey: 'reserve-1',
+        payloadDigest: 'd'.repeat(64), outcome: 'applied', resultRef: 'route-1' };
+    return state;
+}
+function dispatch(state, payload) {
+    (0, apply_1.applyRequestToState)(state, { kind: 'register-entity', requestId: 'dispatch-request',
+        generationToken: 'g1', idempotencyKey: 'dispatch-key', payload: { entity: 'dispatch',
+            dispatchId: 'dispatch-S1', taskId: 'S1', ...payload } }, 'd'.repeat(64), process.cwd());
+}
+function boundRepo(version = 'v1') {
+    const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-196-bound-'));
+    (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'main'], { 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 });
+    fs_1.default.mkdirSync(path_1.default.join(repo, 'plans'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'plans', 'cycle.md'), fs_1.default.readFileSync(path_1.default.join(__dirname, `../../core/plan/fixtures/compact-slices-${version}/valid.md`), 'utf8'));
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'source.md'), '## Canonical source\nfixture source\n');
+    (0, init_1.initWatch)(repo, 'main');
+    const plan = (0, validate_1.validatePlanFile)('plans/cycle.md', repo);
+    if (plan.state !== 'valid')
+        throw new Error('invalid fixture');
+    const state = (0, store_1.readJournal)(repo, 'main').state;
+    state.schema = 2;
+    state.planBinding = { path: 'plans/cycle.md', digest: plan.planDigest, schema: plan.schema,
+        ...(plan.executionDigest ? { executionDigest: plan.executionDigest, executionIdentitySchema: 'awm-plan-execution/v1' } : {}),
+        executionMode: 'desatendido', boundAt: new Date().toISOString() };
+    (0, store_1.writeJournal)(repo, 'main', state);
+    return repo;
+}
+const admitted = { state: 'admitted', planState: 'valid', executionMode: 'desatendido',
+    journal: 'current', currentness: 'current', sensors: 'pass', diagnostics: [] };
+const redSensor = { state: 'blocked', planState: 'valid', executionMode: 'desatendido',
+    journal: 'not-required', currentness: 'current', sensors: 'fail',
+    diagnostics: [{ code: 'ADMISSION_SENSORS_BLOCKED', message: 'format fails during RED' }] };
+describe('issue #196 reopened: supervised S1 handoff', () => {
+    beforeAll(() => {
+        // These tests execute the published CLI entrypoint, not only ts-jest
+        // imports. Rebuild it so source regressions cannot hide behind dist.
+        (0, child_process_1.execFileSync)('npm', ['run', 'build'], {
+            cwd: path_1.default.resolve(__dirname, '../../../'), stdio: 'pipe',
+            // Windows exposes npm as npm.cmd, which requires a shell to spawn.
+            shell: process.platform === 'win32',
+        });
+    }, 30000);
+    test('controller prompt fences only generation-mutating job verbs, not reconcile', () => {
+        const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-196-prompt-'));
+        try {
+            (0, store_1.initJournal)(repo, 'main');
+            (0, generations_1.beginGeneration)(repo, 'main');
+            let argv = [];
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-next-action' }, job => { argv = job.argv; });
+            const prompt = argv.join(' ');
+            expect(prompt).toContain('awm job reconcile');
+            expect(prompt).toMatch(/reconcile[^\n]*sin --generation/);
+            expect(prompt).toMatch(/awm job ack/);
+            expect(prompt).toContain('--generation');
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('v2 dispatch requires an applied matching routing reservation before native launch', () => {
+        const state = v2State();
+        expect(() => dispatch(state, {})).toThrow(/routingAttemptId|routing/i);
+        expect(state.dispatches).toHaveLength(0);
+        expect(() => dispatch(state, { routingAttemptId: 'route-1' })).not.toThrow();
+        expect(state.dispatches).toEqual([expect.objectContaining({ id: 'dispatch-S1', taskId: 'S1', routingAttemptId: 'route-1' })]);
+        expect(state.tasks[0].attempts).toBe(1);
+    });
+    test('v2 dispatch rejects a reservation for another slice without recording work', () => {
+        const state = v2State();
+        state.routingAttempts[0].envelope = { ...routing_approval_1.routingEnvelope, sliceId: 'S2' };
+        expect(() => dispatch(state, { routingAttemptId: 'route-1' })).toThrow(/slice|task|routing/i);
+        expect(state.dispatches).toHaveLength(0);
+        expect(state.tasks[0].attempts).toBe(0);
+    });
+    test('v2 dispatch rejects unknown, unapplied and wrong-plan reservations', () => {
+        for (const scenario of ['unknown', 'unapplied', 'wrong-plan']) {
+            const state = v2State();
+            if (scenario === 'unapplied')
+                delete state.appliedRequests['reserve-1'];
+            if (scenario === 'wrong-plan')
+                state.routingAttempts[0].envelope = {
+                    ...routing_approval_1.routingEnvelope, planDigest: 'a'.repeat(64),
+                };
+            expect(() => dispatch(state, { routingAttemptId: scenario === 'unknown' ? 'missing' : 'route-1' }))
+                .toThrow(/reservation|routing|plan|ack/i);
+            expect(state.dispatches).toHaveLength(0);
+            expect(state.tasks[0].attempts).toBe(0);
+        }
+    });
+    test('replay with a different routing attempt cannot reuse a dispatch ID', () => {
+        const state = v2State();
+        dispatch(state, { routingAttemptId: 'route-1' });
+        state.routingAttempts.push({ ...state.routingAttempts[0], id: 'route-2', reservationRequestId: 'reserve-2', state: 'reserved' });
+        state.appliedRequests['reserve-2'] = { requestId: 'reserve-2', idempotencyKey: 'reserve-2',
+            payloadDigest: 'd'.repeat(64), outcome: 'applied', resultRef: 'route-2' };
+        expect(() => dispatch(state, { routingAttemptId: 'route-2' })).toThrow(/conflict|dispatch/i);
+        expect(state.dispatches).toHaveLength(1);
+        expect(state.tasks[0].attempts).toBe(1);
+    });
+    test('an exact dispatch replay after native observation does not duplicate S1', () => {
+        const state = v2State();
+        dispatch(state, { routingAttemptId: 'route-1' });
+        state.routingAttempts[0].state = 'active';
+        expect(() => dispatch(state, { routingAttemptId: 'route-1' })).not.toThrow();
+        expect(state.dispatches).toHaveLength(1);
+        expect(state.tasks[0].attempts).toBe(1);
+    });
+    test('a reservation cannot create a second dispatch with a different ID', () => {
+        const state = v2State();
+        dispatch(state, { routingAttemptId: 'route-1' });
+        expect(() => dispatch(state, { routingAttemptId: 'route-1', dispatchId: 'dispatch-S1-duplicate' }))
+            .toThrow(/reservation|dispatch|routing/i);
+        expect(state.dispatches).toHaveLength(1);
+        expect(state.tasks[0].attempts).toBe(1);
+    });
+    test('a persisted v2 dispatch cannot point to a missing routing attempt', () => {
+        const state = v2State();
+        dispatch(state, { routingAttemptId: 'route-1' });
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.dispatches[0].routingAttemptId = 'route-missing';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
+    test('an unrelated applied ack cannot stand in for the routing reservation ack', () => {
+        const state = v2State();
+        delete state.appliedRequests['reserve-1'];
+        state.appliedRequests['task-ack'] = { requestId: 'task-ack', idempotencyKey: 'task-ack',
+            payloadDigest: 'd'.repeat(64), outcome: 'applied', resultRef: 'route-1' };
+        expect(() => dispatch(state, { routingAttemptId: 'route-1' })).toThrow(/ack|reservation|routing/i);
+        expect(state.dispatches).toHaveLength(0);
+    });
+    test('v2 implementer dispatch refuses a legacy receipt without native provenance', () => {
+        const state = v2State();
+        state.routingAttempts[0].nativeEvidenceRequired = undefined;
+        expect(() => dispatch(state, { routingAttemptId: 'route-1' })).toThrow(/native|receipt|evidence/i);
+        expect(state.dispatches).toHaveLength(0);
+    });
+    test('v2 native observation cannot precede an acknowledged dispatch', () => {
+        const state = v2State();
+        expect(() => (0, apply_1.applyRequestToState)(state, { kind: 'routing-observe', requestId: 'observe-1', generationToken: 'g1',
+            idempotencyKey: 'observe-1', payload: { attemptId: 'route-1', nativeAgentId: 'child-1',
+                observed: routing_approval_1.routingEnvelope.resolved } }, 'd'.repeat(64), process.cwd())).toThrow(/dispatch|ack/i);
+        expect(state.routingAttempts[0].state).toBe('reserved');
+    });
+    test('a linked dispatch with no task is not a valid journal', () => {
+        const state = v2State();
+        dispatch(state, { routingAttemptId: 'route-1' });
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.tasks = [];
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
+    test('journal ACK map keys must name the same request as their values', () => {
+        const state = v2State();
+        state.appliedRequests['req-wrong'] = { requestId: 'req-other', idempotencyKey: 'alias',
+            payloadDigest: 'd'.repeat(64), outcome: 'applied', resultRef: 'route-1' };
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
+    test('real CLI exposes exact pending and applied request ack without changing the journal', () => {
+        const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-196-ack-'));
+        try {
+            (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'main'], { cwd: repo });
+            (0, store_1.initJournal)(repo, 'main');
+            const emitted = (0, requests_1.emitRequest)(repo, 'main', { kind: 'controller-heartbeat', generationToken: 'g1',
+                idempotencyKey: 'heartbeat-1', payload: {} });
+            const compiled = path_1.default.resolve(__dirname, '../../../dist/src/index.js');
+            const run = (id) => (0, child_process_1.spawnSync)(process.execPath, [compiled, 'job', 'ack', id], {
+                cwd: repo, encoding: 'utf8', env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' },
+            });
+            const pending = run(emitted.requestId);
+            expect(pending.status).toBe(0);
+            expect(JSON.parse(pending.stdout)).toMatchObject({ state: 'pending', requestId: emitted.requestId });
+            (0, apply_1.consumePendingRequests)(repo, 'main', 'g1');
+            const applied = run(emitted.requestId);
+            expect(applied.status).toBe(0);
+            expect(JSON.parse(applied.stdout)).toMatchObject({ state: 'applied', requestId: emitted.requestId });
+            const unknown = run('req-unknown');
+            expect(unknown.status).not.toBe(0);
+            expect(JSON.parse(unknown.stdout)).toMatchObject({ state: 'unknown', requestId: 'req-unknown' });
+            const rejectedRequest = (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g1',
+                idempotencyKey: 'bad-task', payload: { entity: 'task' } });
+            (0, apply_1.consumePendingRequests)(repo, 'main', 'g1');
+            const rejected = run(rejectedRequest.requestId);
+            expect(rejected.status).not.toBe(0);
+            expect(JSON.parse(rejected.stdout)).toMatchObject({ state: 'rejected', requestId: rejectedRequest.requestId });
+            const corruptRequest = (0, requests_1.emitRequest)(repo, 'main', { kind: 'controller-heartbeat', generationToken: 'g1',
+                idempotencyKey: 'bad-json', payload: {} });
+            fs_1.default.writeFileSync(corruptRequest.file, '{malformed');
+            expect(JSON.parse(run(corruptRequest.requestId).stdout)).toMatchObject({ state: 'unverifiable', requestId: corruptRequest.requestId });
+            (0, apply_1.consumePendingRequests)(repo, 'main', 'g1');
+            expect(JSON.parse(run(corruptRequest.requestId).stdout)).toMatchObject({ state: 'unverifiable', requestId: corruptRequest.requestId });
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('ack reports an unsafe or absent request directory as unverifiable', () => {
+        const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-196-ack-dir-'));
+        try {
+            (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'main'], { cwd: repo });
+            (0, store_1.initJournal)(repo, 'main');
+            const dir = (0, paths_1.requestsDir)(repo, 'main');
+            const saved = `${dir}-saved`;
+            fs_1.default.renameSync(dir, saved);
+            const compiled = path_1.default.resolve(__dirname, '../../../dist/src/index.js');
+            const run = () => (0, child_process_1.spawnSync)(process.execPath, [compiled, 'job', 'ack', 'req-absent'], {
+                cwd: repo, encoding: 'utf8', env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' },
+            });
+            const absent = run();
+            expect(absent.status).not.toBe(0);
+            expect(JSON.parse(absent.stdout)).toMatchObject({ state: 'unverifiable', reasonCode: 'request-directory' });
+            fs_1.default.symlinkSync(saved, dir, 'dir');
+            const linked = run();
+            expect(linked.status).not.toBe(0);
+            expect(JSON.parse(linked.stdout)).toMatchObject({ state: 'unverifiable', reasonCode: 'request-directory' });
+            fs_1.default.unlinkSync(dir);
+            fs_1.default.renameSync(saved, dir);
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('an admitted launched generation does not reclassify RED sensor failure as pre-dispatch custody', async () => {
+        const repo = boundRepo();
+        try {
+            let report = admitted;
+            let admissions = 0;
+            let spawns = 0;
+            const sup = new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns += 1; }, undefined, async () => { admissions += 1; return report; }, true);
+            expect(await sup.tick()).toBe('continue');
+            const launched = (0, store_1.readJournal)(repo, 'main').state;
+            expect(launched.generations).toHaveLength(1);
+            expect(launched.generations[0].launchArgvDigest).toBeDefined();
+            const gen = launched.generations[0];
+            gen.processRef = { pid: process.pid, processGroup: process.pid, startTime: 'fixture',
+                spawnNonce: gen.spawnNonce, argvDigest: gen.launchArgvDigest, psArgsDigest: 'b'.repeat(64) };
+            (0, store_1.writeJournal)(repo, 'main', launched);
+            const adapter = adapterModule.adapterFor('codex');
+            jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter,
+                activity: () => ({ cpuTime: '0', groupSize: 1 }), safeToReplace: () => 'indeterminate' });
+            fs_1.default.writeFileSync(path_1.default.join(repo, 's1-red.test.ts'), 'test("RED", () => { throw new Error("RED"); });\n');
+            (0, request_1.requestJob)(repo, 'main', gen.token, [process.execPath, '-e', 'process.exit(0)'], [], '.');
+            report = redSensor;
+            expect(await sup.tick()).toBe('continue');
+            const duringRed = (0, store_1.readJournal)(repo, 'main').state;
+            expect(duringRed.cycle.status).toBe('IN_PROGRESS');
+            expect(duringRed.generations).toHaveLength(1);
+            expect(admissions).toBe(1);
+            expect(spawns).toBe(2); // one controller launch, then the pending job during RED
+            expect(Object.keys(duringRed.jobs)).toHaveLength(1);
+        }
+        finally {
+            jest.restoreAllMocks();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('the same RED continuation applies to compact v2 with unchanged native scope', async () => {
+        const repo = boundRepo('v2');
+        try {
+            const runtime = routing_approval_1.routingEnvelope.runtime;
+            const scope = { runtime, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+            jest.spyOn(localScope, 'queryLocalEventScope').mockResolvedValue({ state: 'current', scope });
+            jest.spyOn(eventStore, 'readStoredEventReceipt').mockReturnValue({ state: 'present', receipt: {
+                    schema: 'routing-capabilities/v2', ...scope, recordedAt: new Date().toISOString(), claims: [],
+                } });
+            let report = admitted;
+            let admissions = 0;
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, routingIdentity: {
+                    kind: runtime.kind, version: runtime.version, accountScopeDigest: runtime.accountScopeDigest,
+                }, controllerAutonomy: 'approval-free' };
+            const sup = new supervisor_1.Supervisor(repo, 'main', cfg, () => { }, undefined, async () => { admissions += 1; return report; }, true);
+            expect(await sup.tick()).toBe('continue');
+            const gen = (0, store_1.readJournal)(repo, 'main').state.generations[0];
+            fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'main'), gen.controllerJobId, gen.spawnNonce), '{}');
+            report = redSensor;
+            expect(await sup.tick()).toBe('continue');
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('IN_PROGRESS');
+            expect(admissions).toBe(1);
+        }
+        finally {
+            jest.restoreAllMocks();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('a new generation still fails closed when sensors are red', async () => {
+        const repo = boundRepo();
+        try {
+            let report = admitted;
+            const sup = new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { }, undefined, async () => report, true);
+            expect(await sup.tick()).toBe('continue');
+            const state = (0, store_1.readJournal)(repo, 'main').state;
+            state.generations[0].state = 'terminated';
+            (0, store_1.writeJournal)(repo, 'main', state);
+            report = redSensor;
+            expect(await sup.tick()).toBe('custody');
+            expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(1);
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('an active v2 generation refuses dispatch when local runtime identity drifts', async () => {
+        const repo = boundRepo('v2');
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => { });
+            const gen = (0, store_1.readJournal)(repo, 'main').state.generations[0];
+            fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'main'), gen.controllerJobId, gen.spawnNonce), '{}');
+            const expected = routing_approval_1.routingEnvelope.runtime;
+            jest.spyOn(localScope, 'queryLocalEventScope').mockResolvedValue({ state: 'current', scope: {
+                    runtime: { ...expected, version: '99.0.0' }, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64),
+                } });
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, routingIdentity: {
+                    kind: expected.kind, version: expected.version, accountScopeDigest: expected.accountScopeDigest,
+                }, controllerAutonomy: 'approval-free' };
+            expect(await new supervisor_1.Supervisor(repo, 'main', cfg, () => { }, undefined, async () => admitted, true).tick()).toBe('custody');
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+        }
+        finally {
+            jest.restoreAllMocks();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('crash before controller claim rechecks admission before retrying the launch', async () => {
+        const repo = boundRepo();
+        try {
+            let attempts = 0;
+            const spawn = () => { attempts += 1; throw new Error('launch offline'); };
+            expect(await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, spawn, undefined, async () => admitted, true).tick()).toBe('continue');
+            const intent = (0, store_1.readJournal)(repo, 'main').state.generations[0];
+            expect(intent.launchArgvDigest).toBeDefined();
+            expect(intent.wrapperRef).toBeUndefined();
+            expect(attempts).toBe(1);
+            expect(await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, spawn, undefined, async () => redSensor, true).tick()).toBe('custody');
+            expect(attempts).toBe(1);
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('replacement after a stalled generation waits for fresh admission', async () => {
+        const repo = boundRepo();
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => { });
+            const state = (0, store_1.readJournal)(repo, 'main').state;
+            state.generations[0].processRef = { pid: 99999999, processGroup: 99999999, startTime: 'Thu Sep 24 20:00:00 2026',
+                spawnNonce: 'n', argvDigest: 'a'.repeat(64), psArgsDigest: 'b'.repeat(64) };
+            state.controllerHeartbeatAt = new Date(Date.now() - 3600_000).toISOString();
+            (0, store_1.writeJournal)(repo, 'main', state);
+            (0, request_1.requestJob)(repo, 'main', state.generations[0].token, [process.execPath, '-e', 'process.exit(0)'], [], '.');
+            const adapter = adapterModule.adapterFor('codex');
+            jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter, activity: () => null, safeToReplace: () => 'safe' });
+            jest.spyOn(generationModule, 'resolveGeneration').mockImplementation(async () => {
+                const current = (0, store_1.readJournal)(repo, 'main').state;
+                current.generations[0].state = 'terminated';
+                (0, store_1.writeJournal)(repo, 'main', current);
+                return 'proven-dead';
+            });
+            let admissions = 0;
+            let jobSpawns = 0;
+            const sup = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, heartbeatTimeoutMs: 0, activityWindowMs: 0 }, () => { jobSpawns += 1; }, undefined, async () => { admissions += 1; return redSensor; }, true);
+            expect(await sup.tick()).toBe('custody');
+            expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(1);
+            expect(admissions).toBe(1);
+            expect(jobSpawns).toBe(0);
+        }
+        finally {
+            jest.restoreAllMocks();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('relaunch backoff does not start received jobs under the dead generation', async () => {
+        const repo = boundRepo();
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => { });
+            const state = (0, store_1.readJournal)(repo, 'main').state;
+            state.generations[0].processRef = { pid: 99999998, processGroup: 99999998, startTime: 'Thu Sep 24 20:00:00 2026',
+                spawnNonce: 'n', argvDigest: 'a'.repeat(64), psArgsDigest: 'b'.repeat(64) };
+            state.controllerHeartbeatAt = new Date().toISOString();
+            (0, store_1.writeJournal)(repo, 'main', state);
+            (0, request_1.requestJob)(repo, 'main', state.generations[0].token, [process.execPath, '-e', 'process.exit(0)'], [], '.');
+            const adapter = adapterModule.adapterFor('codex');
+            jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter, activity: () => null, safeToReplace: () => 'safe' });
+            jest.spyOn(generationModule, 'resolveGeneration').mockResolvedValue('proven-dead');
+            let spawns = 0;
+            let admissions = 0;
+            const sup = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, heartbeatTimeoutMs: 60_000, activityWindowMs: 0 }, () => { spawns += 1; }, undefined, async () => { admissions += 1; return admitted; }, true);
+            sup.relaunchNotBefore = Date.now() + 60_000;
+            expect(await sup.tick()).toBe('continue');
+            expect(spawns).toBe(0);
+            expect(admissions).toBe(0);
+        }
+        finally {
+            jest.restoreAllMocks();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('failed initial controller launch cannot start received jobs during backoff', async () => {
+        const repo = boundRepo();
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            const token = (0, store_1.readJournal)(repo, 'main').state.generations[0].token;
+            (0, request_1.requestJob)(repo, 'main', token, [process.execPath, '-e', 'process.exit(0)'], [], '.');
+            let jobSpawns = 0;
+            const sup = new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { jobSpawns += 1; throw new Error('controller launch offline'); }, undefined, async () => admitted, true);
+            expect(await sup.tick()).toBe('continue');
+            expect(jobSpawns).toBe(1); // failed controller launch only
+            expect((0, store_1.readJournal)(repo, 'main').state.generations[0].processRef).toBeUndefined();
+            expect(await sup.tick()).toBe('continue');
+            expect(jobSpawns).toBe(1); // no controller retry and no job dispatch in backoff
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('unadopted controller wrapper cannot start received jobs', async () => {
+        const repo = boundRepo();
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            const token = (0, store_1.readJournal)(repo, 'main').state.generations[0].token;
+            (0, request_1.requestJob)(repo, 'main', token, [process.execPath, '-e', 'process.exit(0)'], [], '.');
+            const wrapper = { pid: process.pid, processGroup: process.pid, startTime: 'Thu Sep 24 20:00:00 2026',
+                spawnNonce: 'n', argvDigest: 'a'.repeat(64), psArgsDigest: 'b'.repeat(64) };
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => wrapper);
+            let jobSpawns = 0;
+            const sup = new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { jobSpawns += 1; }, undefined, async () => admitted, true);
+            expect(await sup.tick()).toBe('continue');
+            expect(jobSpawns).toBe(0);
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('watch CLI never announces COMPLETE when the loop stops with an in-progress journal', async () => {
+        const repo = boundRepo();
+        const originalCwd = process.cwd();
+        const output = [];
+        const write = jest.spyOn(process.stdout, 'write').mockImplementation(chunk => { output.push(String(chunk)); return true; });
+        const loop = jest.spyOn(supervisorModule, 'runSupervisorLoop').mockResolvedValue('stopped');
+        try {
+            process.chdir(repo);
+            const program = new commander_1.Command();
+            (0, watch_1.registerWatchCommand)(program);
+            await program.parseAsync(['node', 'awm', 'watch']);
+            expect(loop).toHaveBeenCalled();
+            expect(output.join('')).not.toContain('COMPLETE');
+            expect(output.join('')).toMatch(/IN_PROGRESS|detenido/i);
+        }
+        finally {
+            process.chdir(originalCwd);
+            write.mockRestore();
+            loop.mockRestore();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('a frozen loop with a corrupt final journal exits nonzero', async () => {
+        const repo = boundRepo();
+        const previousCwd = process.cwd();
+        const previousExitCode = process.exitCode;
+        const output = [];
+        const write = jest.spyOn(process.stdout, 'write').mockImplementation(chunk => { output.push(String(chunk)); return true; });
+        const loop = jest.spyOn(supervisorModule, 'runSupervisorLoop').mockImplementation(async () => {
+            fs_1.default.writeFileSync((0, paths_1.statePath)(repo, 'main'), '{corrupt');
+            return 'frozen';
+        });
+        try {
+            process.chdir(repo);
+            const program = new commander_1.Command();
+            (0, watch_1.registerWatchCommand)(program);
+            await program.parseAsync(['node', 'awm', 'watch']);
+            expect(process.exitCode).toBe(1);
+            expect(output.join('')).not.toContain('gate verde');
+            expect(output.join('')).not.toContain('COMPLETE');
+        }
+        finally {
+            process.chdir(previousCwd);
+            process.exitCode = previousExitCode;
+            write.mockRestore();
+            loop.mockRestore();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    (process.platform === 'win32' ? test.skip : test)('real SIGINT stops the loop without claiming COMPLETE', async () => {
+        const repo = boundRepo();
+        const compiled = path_1.default.resolve(__dirname, '../../../dist/src/commands/watch/supervisor.js');
+        const script = `const s=require(${JSON.stringify(compiled)}); const report={state:'admitted',planState:'valid',executionMode:'desatendido',journal:'current',currentness:'current',sensors:'pass',diagnostics:[]}; process.on('newListener',function ready(event){if(event==='SIGINT'){process.removeListener('newListener',ready);setImmediate(()=>console.log('SIGINT_READY'))}}); s.runSupervisorLoop(process.cwd(),'main',{...s.DEFAULT_SUPERVISOR_CONFIG,tickMs:30},()=>{},undefined,async()=>report).then(out=>console.log(JSON.stringify({out}))).catch(e=>{console.error(e);process.exitCode=2})`;
+        const child = (0, child_process_1.spawn)(process.execPath, ['-e', script], { cwd: repo, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', chunk => { stdout += String(chunk); });
+        child.stderr.on('data', chunk => { stderr += String(chunk); });
+        try {
+            const deadline = Date.now() + 4000;
+            // The lock is acquired just before the signal handler is installed.
+            // Wait for the child's readiness marker to avoid killing it in that gap.
+            while ((!fs_1.default.existsSync((0, paths_2.supervisorLockPath)(repo)) || !stdout.includes('SIGINT_READY')) && child.exitCode === null && Date.now() < deadline) {
+                await new Promise(resolve => setTimeout(resolve, 25));
+            }
+            expect(fs_1.default.existsSync((0, paths_2.supervisorLockPath)(repo))).toBe(true);
+            expect(stdout).toContain('SIGINT_READY');
+            child.kill('SIGINT');
+            const exit = await new Promise(resolve => child.once('exit', code => resolve(code)));
+            expect(exit).toBe(0);
+            expect(stdout).toContain('"out":"stopped"');
+            expect(stdout).not.toContain('COMPLETE');
+            expect(stderr).not.toContain('Error');
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('IN_PROGRESS');
+        }
+        finally {
+            if (child.exitCode === null)
+                child.kill('SIGKILL');
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    }, 10000);
+    (process.platform === 'win32' ? test.skip : test)('compiled watch CLI reports interrupted journal truthfully', async () => {
+        const repo = boundRepo();
+        const supervisor = path_1.default.resolve(__dirname, '../../../dist/src/commands/watch/supervisor.js');
+        const index = path_1.default.resolve(__dirname, '../../../dist/src/index.js');
+        const harness = `const s=require(${JSON.stringify(supervisor)}); const keep=setInterval(()=>{},1000); s.runSupervisorLoop=()=>new Promise(resolve=>process.on('SIGINT',()=>{clearInterval(keep);resolve('stopped')})); process.argv=[process.execPath,${JSON.stringify(index)},'watch']; require(${JSON.stringify(index)}).program.parseAsync(process.argv).catch(e=>{console.error(e);process.exitCode=2});`;
+        const child = (0, child_process_1.spawn)(process.execPath, ['-e', harness], { cwd: repo, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', chunk => { stdout += String(chunk); });
+        child.stderr.on('data', chunk => { stderr += String(chunk); });
+        try {
+            const deadline = Date.now() + 4000;
+            while (!stdout.includes('supervisor activo') && child.exitCode === null && Date.now() < deadline) {
+                await new Promise(resolve => setTimeout(resolve, 25));
+            }
+            expect(stdout).toContain('supervisor activo');
+            child.kill('SIGINT');
+            const exit = await new Promise(resolve => child.once('close', code => resolve(code)));
+            expect(exit).toBe(130);
+            expect(stdout).toMatch(/detenido; ciclo IN_PROGRESS/);
+            expect(stdout).not.toContain('COMPLETE');
+            expect(stderr).not.toContain('Error');
+        }
+        finally {
+            if (child.exitCode === null)
+                child.kill('SIGKILL');
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    }, 10000);
+    test('recovered v2 S1 uses real CLI reservation, dispatch ack, observation and one continuation', async () => {
+        const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-196-integral-'));
+        const previousHome = process.env.AWM_HOME;
+        const operator = path_1.default.join(repo, 'operator');
+        try {
+            (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'main'], { 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 });
+            fs_1.default.mkdirSync(path_1.default.join(repo, 'plans'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(repo, 'plans', 'cycle.md'), fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v2/valid.md'), 'utf8'));
+            fs_1.default.writeFileSync(path_1.default.join(repo, 'source.md'), '## Canonical source\nfixture source\n');
+            const plan = (0, validate_1.validatePlanFile)('plans/cycle.md', repo);
+            if (plan.state !== 'valid' || !plan.executionDigest)
+                throw new Error('invalid v2 fixture');
+            (0, init_1.initWatch)(repo, 'main', { path: 'plans/cycle.md', report: plan });
+            const blocked = (0, store_1.readJournal)(repo, 'main').state;
+            blocked.cycle.status = 'BLOCKED';
+            blocked.cycle.blockedReason = 'admisión compacta desatendida bloqueada antes de dispatch: ADMISSION_CURRENTNESS_BLOCKED: registry:baseline unverifiable';
+            (0, store_1.writeJournal)(repo, 'main', blocked);
+            const runtime = routing_approval_1.routingEnvelope.runtime;
+            const scope = { runtime, binaryDigest: 'b'.repeat(64), configDigest: 'c'.repeat(64) };
+            jest.spyOn(eventStore, 'readStoredEventReceipt').mockReturnValue({ state: 'present', receipt: {
+                    schema: 'routing-capabilities/v2', ...scope, recordedAt: new Date().toISOString(), claims: [],
+                } });
+            jest.spyOn(localScope, 'queryLocalEventScope').mockResolvedValue({ state: 'current', scope });
+            expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', { provider: 'codex',
+                routingIdentity: { kind: runtime.kind, version: runtime.version, accountScopeDigest: runtime.accountScopeDigest },
+                controllerAutonomy: 'approval-free', reason: 'Reverified local gates' }, async () => admitted)).toBe('recovered');
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('IN_PROGRESS');
+            jest.restoreAllMocks();
+            const generation = (0, generations_1.beginGeneration)(repo, 'main');
+            fs_1.default.mkdirSync(operator);
+            process.env.AWM_HOME = operator;
+            const machineKey = (0, machine_key_1.ensureMachineKey)(operator);
+            const approval = (0, routing_approval_2.routingApproval)();
+            approval.policy.content.mappings[0].degradation.allowMissingObservedIdentity = true;
+            approval.policy.contentDigest = (0, canonical_1.canonicalPolicyDigest)(approval.policy.content);
+            fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'model-policy.json'), JSON.stringify(approval.policy));
+            const enrolledAt = new Date(Date.now() - 1000).toISOString();
+            const eventDigest = 'e'.repeat(64);
+            const eventReceipt = { schema: 'routing-capabilities/v2', ...scope, recordedAt: enrolledAt,
+                claims: [{ selection: routing_approval_1.routingEnvelope.resolved,
+                        mappingDigest: (0, selection_policy_digest_1.selectionPolicyDigest)(approval.policy.content.mappings[0], routing_approval_1.routingEnvelope.resolved),
+                        eventDigest, source: 'codex-turn-context', observedAt: enrolledAt,
+                        actualModel: 'unverified', tokenUsage: 'unknown' }] };
+            const receipt = path_1.default.join(operator, 'routing-capabilities-v2', 'codex', 'native.json');
+            fs_1.default.mkdirSync(path_1.default.dirname(receipt), { recursive: true });
+            const mac = (0, crypto_1.createHmac)('sha256', machineKey).update('AWM routing-capabilities/v2 local receipt\0')
+                .update(JSON.stringify(eventReceipt)).digest('hex');
+            fs_1.default.writeFileSync(receipt, JSON.stringify({ receipt: eventReceipt, mac }));
+            const envelope = { ...routing_approval_1.routingEnvelope, planDigest: plan.planDigest, executionDigest: plan.executionDigest,
+                policyDigest: approval.policy.contentDigest,
+                capabilityDigest: (0, crypto_1.createHash)('sha256').update(JSON.stringify(eventReceipt)).digest('hex'),
+                outcome: 'degraded', unavailableEvidence: ['observedModelEvidence'] };
+            const envelopeFile = path_1.default.join(repo, 'envelope.json');
+            fs_1.default.writeFileSync(envelopeFile, JSON.stringify(envelope));
+            const compiled = path_1.default.resolve(__dirname, '../../../dist/src/index.js');
+            const cli = (...args) => {
+                const result = (0, child_process_1.spawnSync)(process.execPath, [compiled, 'job', ...args], { cwd: repo, encoding: 'utf8',
+                    env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' } });
+                if (result.status !== 0)
+                    throw new Error(`CLI ${args.join(' ')}: ${result.stderr} ${result.stdout}`);
+                return JSON.parse(result.stdout);
+            };
+            const task = cli('register', '--generation', generation.token, '--entity', 'task', '--json', JSON.stringify({
+                taskId: 'S1', title: 'Implement S1', verificationPlan: [], reviewObligations: [],
+            }));
+            expect(cli('ack', task.requestId).state).toBe('pending');
+            (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
+            expect((0, store_1.readJournal)(repo, 'main').state.requestProblems).toEqual([]);
+            expect(cli('ack', task.requestId).state).toBe('applied');
+            const reserve = cli('routing-reserve', '--generation', generation.token, '--obligation', 'S1-implementer', '--lineage', 'lineage-S1', '--envelope-file', envelopeFile, '--fingerprint', 'f'.repeat(64));
+            expect(cli('ack', reserve.requestId).state).toBe('pending');
+            (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
+            expect((0, store_1.readJournal)(repo, 'main').state.requestProblems).toEqual([]);
+            const reservation = cli('ack', reserve.requestId);
+            expect(reservation.state).toBe('applied');
+            const attemptId = reservation.resultRef;
+            const dispatchPayload = JSON.stringify({ dispatchId: 'dispatch-S1', taskId: 'S1', routingAttemptId: attemptId });
+            const queuedDispatch = cli('register', '--generation', generation.token, '--entity', 'dispatch', '--json', dispatchPayload);
+            expect(cli('ack', queuedDispatch.requestId).state).toBe('pending');
+            expect(fs_1.default.existsSync(path_1.default.join(repo, 's1-red.test.ts'))).toBe(false);
+            (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
+            expect(cli('ack', queuedDispatch.requestId)).toMatchObject({ state: 'applied', resultRef: 'dispatch-S1' });
+            const worker = (0, child_process_1.spawnSync)(process.execPath, ['-e', `require('fs').writeFileSync(${JSON.stringify(path_1.default.join(repo, 's1-red.test.ts'))}, 'test("RED", () => { throw new Error("RED"); });\\n')`], {
+                cwd: repo, encoding: 'utf8', env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' },
+            });
+            expect(worker.status).toBe(0);
+            expect(fs_1.default.existsSync(path_1.default.join(repo, 's1-red.test.ts'))).toBe(true);
+            const proof = (0, native_routing_proof_1.signNativeRoutingProof)({ attemptId, nativeAgentId: 'native-child-1', source: 'codex-turn-context',
+                eventDigest, observedAt: new Date().toISOString(), selection: envelope.resolved }, machineKey);
+            const observation = (0, requests_1.emitRequest)(repo, 'main', { kind: 'routing-observe', generationToken: generation.token,
+                idempotencyKey: 'native-observation-S1', payload: { attemptId, nativeAgentId: 'native-child-1',
+                    observed: envelope.resolved, nativeProof: proof } });
+            (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
+            expect(cli('ack', observation.requestId).state).toBe('applied');
+            const replay = cli('register', '--generation', generation.token, '--entity', 'dispatch', '--json', dispatchPayload);
+            (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
+            expect(cli('ack', replay.requestId).state).toBe('applied');
+            expect(cli('reconcile').nextAction).toBeTruthy();
+            const unsupported = (0, child_process_1.spawnSync)(process.execPath, [compiled, 'job', 'reconcile', '--generation', generation.token], {
+                cwd: repo, encoding: 'utf8', env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' },
+            });
+            expect(unsupported.status).not.toBe(0);
+            expect(unsupported.stderr).toMatch(/generation|unknown option/i);
+            const final = (0, store_1.readJournal)(repo, 'main').state;
+            expect(final.tasks).toHaveLength(1);
+            expect(final.dispatches).toHaveLength(1);
+            expect(final.routingAttempts).toHaveLength(1);
+            expect(final.routingAttempts[0].state).toBe('active');
+            expect(final.tasks[0].attempts).toBe(1);
+            expect(Object.keys(final.jobs)).toHaveLength(0);
+        }
+        finally {
+            jest.restoreAllMocks();
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+});