agentic-workflow-manager 9.12.0 → 9.12.2

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

@@ -0,0 +1,278 @@
+"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 child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const init_1 = require("../../../src/commands/watch/init");
+const store_1 = require("../../../src/core/journal/store");
+const validate_1 = require("../../../src/core/plan/validate");
+const process_1 = require("../../../src/core/journal/process");
+const eventStore = __importStar(require("../../../src/core/model-policy/event-store"));
+const localScope = __importStar(require("../../../src/core/model-policy/local-event-scope"));
+const supervisor_1 = require("../../../src/commands/watch/supervisor");
+const admission_recovery_1 = require("../../../src/commands/watch/admission-recovery");
+const watch_1 = require("../../../src/commands/watch");
+const supervisorModule = __importStar(require("../../../src/commands/watch/supervisor"));
+const DIGEST = 'a'.repeat(64);
+const identity = { kind: 'native', version: '1.0.0', accountScopeDigest: DIGEST };
+const input = { provider: 'codex', routingIdentity: identity, controllerAutonomy: 'approval-free',
+    generationToken: 'legacy-1', reason: 'Operador verificó currentness y recibos vigentes' };
+const admitted = async () => ({ state: 'admitted', planState: 'valid', executionMode: 'desatendido', journal: 'current', currentness: 'current', sensors: 'pass', diagnostics: [] });
+const blocked = (code, currentness, sensors) => async () => ({ state: 'blocked', planState: 'valid', executionMode: 'desatendido', journal: 'not-required', currentness, sensors, diagnostics: [{ code, message: 'still blocked' }] });
+describe('issue #196: admission custody recovery', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admission-recovery-'));
+        (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-v1/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, executionMode: 'desatendido', boundAt: new Date().toISOString() };
+        state.generations.push({ n: 1, token: input.generationToken, state: 'terminated', launchedAt: new Date().toISOString(), provider: 'codex' });
+        state.cycle.status = 'BLOCKED';
+        state.cycle.blockedReason = 'admisión compacta desatendida bloqueada antes de dispatch: ADMISSION_CURRENTNESS_BLOCKED: Consumed contract currentness is unverifiable: registry:baseline.';
+        (0, store_1.writeJournal)(repo, 'main', state);
+        jest.spyOn(eventStore, 'readStoredEventReceipt').mockImplementation(runtime => ({ state: 'present', receipt: {
+                schema: 'routing-capabilities/v2', runtime, binaryDigest: DIGEST, configDigest: DIGEST,
+                recordedAt: new Date().toISOString(), claims: [],
+            } }));
+        jest.spyOn(localScope, 'queryLocalEventScope').mockImplementation(async (_cwd, target, kind) => ({ state: 'current', scope: {
+                runtime: { target, kind, version: identity.version, accountScopeDigest: identity.accountScopeDigest },
+                binaryDigest: DIGEST, configDigest: DIGEST,
+            } }));
+    });
+    afterEach(() => { jest.restoreAllMocks(); fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('legacy currentness custody resumes once with original reason, generation and nextAction retained', async () => {
+        const original = (0, store_1.readJournal)(repo, 'main').state;
+        expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).toBe('recovered');
+        const result = (0, store_1.readJournal)(repo, 'main').state;
+        expect(result.cycle.status).toBe('IN_PROGRESS');
+        expect(result.cycle.nextAction).toEqual(original.cycle.nextAction);
+        expect(result.generations).toEqual(original.generations);
+        expect(result.tasks).toEqual(original.tasks);
+        expect(result.dispatches).toEqual(original.dispatches);
+        expect(result.jobs).toEqual(original.jobs);
+        expect(result).toHaveProperty('admissionRecoveries.0.blockedReason', original.cycle.blockedReason);
+        expect(result).toHaveProperty('admissionRecoveries.0.generationToken', input.generationToken);
+        const revision = result.revision;
+        expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).toBe('already-recovered');
+        expect((0, store_1.readJournal)(repo, 'main').state.revision).toBe(revision);
+    });
+    test('persistent unverifiable currentness → custody without generation → explicit recovery → one launch', async () => {
+        const initial = (0, store_1.readJournal)(repo, 'main').state;
+        initial.generations = [];
+        initial.cycle.status = 'IN_PROGRESS';
+        initial.cycle.blockedReason = undefined;
+        (0, store_1.writeJournal)(repo, 'main', initial);
+        let now = Date.now();
+        jest.spyOn(Date, 'now').mockImplementation(() => now);
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, routingIdentity: identity, controllerAutonomy: 'approval-free' };
+        const transient = blocked('ADMISSION_CURRENTNESS_BLOCKED', 'unverifiable', 'not-required');
+        let spawns = 0;
+        for (let i = 0; i < supervisor_1.MAX_SENSOR_DEFERRALS + 1; i++) {
+            const outcome = await new supervisor_1.Supervisor(repo, 'main', cfg, () => { spawns++; }, undefined, transient, true).tick();
+            expect(outcome).toBe(i < supervisor_1.MAX_SENSOR_DEFERRALS ? 'continue' : 'custody');
+            now += 5000;
+        }
+        const held = (0, store_1.readJournal)(repo, 'main').state;
+        expect(held.generations).toHaveLength(0);
+        expect(held.tasks).toHaveLength(0);
+        expect(spawns).toBe(0);
+        expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', { ...input, generationToken: undefined }, admitted)).toBe('recovered');
+        expect(await new supervisor_1.Supervisor(repo, 'main', cfg, () => { spawns++; }, undefined, admitted, true).tick()).toBe('continue');
+        const resumed = (0, store_1.readJournal)(repo, 'main').state;
+        expect(resumed.generations).toHaveLength(1);
+        expect(resumed.cycle.nextAction).toEqual(held.cycle.nextAction);
+        expect(resumed.jobs).toEqual({});
+        expect(resumed.dispatches).toEqual([]);
+        expect(spawns).toBeGreaterThan(0);
+    });
+    test('persistent currentness and sensor failures leave custody untouched', async () => {
+        for (const [code, currentness, sensors] of [
+            ['ADMISSION_CURRENTNESS_BLOCKED', 'unverifiable', 'not-required'],
+            ['ADMISSION_SENSORS_BLOCKED', 'current', 'not-certified'],
+        ]) {
+            const revision = (0, store_1.readJournal)(repo, 'main').state.revision;
+            await expect((0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, blocked(code, currentness, sensors))).rejects.toThrow(/admisión|currentness|sensores/i);
+            expect((0, store_1.readJournal)(repo, 'main').state.revision).toBe(revision);
+        }
+    });
+    test('legacy recovery refuses a missing native receipt even when v1 plan admission says admitted', async () => {
+        jest.spyOn(eventStore, 'readStoredEventReceipt').mockReturnValue({ state: 'absent' });
+        const revision = (0, store_1.readJournal)(repo, 'main').state.revision;
+        await expect((0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).rejects.toThrow(/recibo|receipt/i);
+        expect((0, store_1.readJournal)(repo, 'main').state.revision).toBe(revision);
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+    });
+    test('sensor custody can recover only after sensors pass', async () => {
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        state.cycle.blockedReason = 'admisión sensors no verificable tras 3 reintentos: ADMISSION_SENSORS_BLOCKED: not-certified';
+        (0, store_1.writeJournal)(repo, 'main', state);
+        await expect((0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, blocked('ADMISSION_SENSORS_BLOCKED', 'current', 'not-certified'))).rejects.toThrow();
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+        expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).toBe('recovered');
+    });
+    test('changed binding, active request problem, pending job and identity mismatch all fail closed', async () => {
+        const check = async (mutate, pattern) => {
+            const state = (0, store_1.readJournal)(repo, 'main').state;
+            mutate(state);
+            (0, store_1.writeJournal)(repo, 'main', state);
+            const revision = (0, store_1.readJournal)(repo, 'main').state.revision;
+            await expect((0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).rejects.toThrow(pattern);
+            expect((0, store_1.readJournal)(repo, 'main').state.revision).toBe(revision);
+        };
+        await check(state => { state.planBinding.digest = DIGEST; }, /binding|plan/i);
+        const validPlan = (0, validate_1.validatePlanFile)('plans/cycle.md', repo);
+        if (validPlan.state !== 'valid')
+            throw new Error('fixture changed');
+        const s1 = (0, store_1.readJournal)(repo, 'main').state;
+        s1.planBinding.digest = validPlan.planDigest;
+        (0, store_1.writeJournal)(repo, 'main', s1);
+        await check(state => { state.requestProblems.push({ file: 'rejected', kind: 'rejected', detail: 'x', at: new Date().toISOString() }); }, /request/i);
+        const s2 = (0, store_1.readJournal)(repo, 'main').state;
+        s2.requestProblems = [];
+        (0, store_1.writeJournal)(repo, 'main', s2);
+        await check(state => { state.jobs['J1'] = { id: 'J1', fingerprint: 'x', commandDigest: 'x', argv: ['true'], cwd: '.', paths: [], expandedPaths: [], executionState: 'received', observationState: 'progressing', phaseTimestamps: {} }; }, /job/i);
+        const sJob = (0, store_1.readJournal)(repo, 'main').state;
+        sJob.jobs = {};
+        (0, store_1.writeJournal)(repo, 'main', sJob);
+        await check(state => { state.generations[0].processRef = (0, process_1.captureSelfRef)('recovery-test'); }, /controller/i);
+        const sController = (0, store_1.readJournal)(repo, 'main').state;
+        sController.generations[0].processRef = undefined;
+        (0, store_1.writeJournal)(repo, 'main', sController);
+        await check(state => { state.generations[0].provider = 'claude-code'; }, /provider|identidad/i);
+        const s3 = (0, store_1.readJournal)(repo, 'main').state;
+        s3.generations[0].provider = 'codex';
+        (0, store_1.writeJournal)(repo, 'main', s3);
+        await expect((0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', { ...input, routingIdentity: { ...identity, accountScopeDigest: 'bad' } }, admitted)).rejects.toThrow(/runtime|digest/i);
+    });
+    test('an independent missing required verifier keeps the cycle BLOCKED', async () => {
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        state.requiredVerifiers = ['test'];
+        state.tasks.push({ id: 'S1', title: 'complete claim', status: 'done', attempts: 1, verificationPlan: [], reviewObligations: [] });
+        (0, store_1.writeJournal)(repo, 'main', state);
+        const revision = (0, store_1.readJournal)(repo, 'main').state.revision;
+        await expect((0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).rejects.toThrow(/verificador|required/i);
+        expect((0, store_1.readJournal)(repo, 'main').state.revision).toBe(revision);
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+    });
+    test('a long-lived cycle can recover again after 128 prior audited decisions', async () => {
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        state.admissionRecoveries = Array.from({ length: 128 }, (_, index) => ({
+            at: new Date().toISOString(), reason: `prior-${index}`, blockedReason: state.cycle.blockedReason,
+            generationToken: input.generationToken, context: { provider: 'codex', runtime: identity, controllerAutonomy: 'approval-free' },
+            planDigest: state.planBinding.digest, assertion: 'legacy-operator-asserted',
+        }));
+        (0, store_1.writeJournal)(repo, 'main', state);
+        expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).toBe('recovered');
+        expect((0, store_1.readJournal)(repo, 'main').state.admissionRecoveries).toHaveLength(129);
+    });
+    test('after audited recovery supervisor still rechecks admission before any dispatch', async () => {
+        await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted);
+        let spawns = 0;
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', routingIdentity: identity, controllerAutonomy: 'approval-free' };
+        const sup = new supervisor_1.Supervisor(repo, 'main', cfg, () => { spawns++; }, undefined, blocked('ADMISSION_CURRENTNESS_BLOCKED', 'unverifiable', 'not-required'));
+        expect(await sup.tick()).toBe('continue');
+        expect(spawns).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').state.tasks).toHaveLength(0);
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.nextAction?.actionId).toBe('bootstrap-cycle');
+    });
+    test('public watch recover-admission CLI records one offline transition', async () => {
+        const before = (0, store_1.readJournal)(repo, 'main').state;
+        before.tasks.push({ id: 'S1', title: 'pending work', status: 'pending', attempts: 0, verificationPlan: [], reviewObligations: [] });
+        (0, store_1.writeJournal)(repo, 'main', before);
+        jest.spyOn(supervisorModule, 'admissionForConfig').mockReturnValue(admitted);
+        const cwd = jest.spyOn(process, 'cwd').mockReturnValue(repo);
+        const stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const program = new commander_1.Command();
+        program.exitOverride();
+        (0, watch_1.registerWatchCommand)(program);
+        try {
+            await program.parseAsync(['node', 'awm', 'watch', 'recover-admission',
+                '--provider', 'codex', '--runtime-kind', identity.kind, '--runtime-version', identity.version,
+                '--account-scope-digest', identity.accountScopeDigest, '--controller-autonomy', 'approval-free',
+                '--generation', input.generationToken, '--reason', input.reason]);
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('IN_PROGRESS');
+            expect(stdout.mock.calls.map(call => String(call[0])).join('')).toContain('"recovered":true');
+            let spawned = 0;
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', routingIdentity: identity, controllerAutonomy: 'approval-free' };
+            const outcome = await new supervisor_1.Supervisor(repo, 'main', cfg, () => { spawned++; }, undefined, admitted, true).tick();
+            expect({ outcome, blockedReason: (0, store_1.readJournal)(repo, 'main').state.cycle.blockedReason }).toEqual({ outcome: 'continue', blockedReason: undefined });
+            const resumed = (0, store_1.readJournal)(repo, 'main').state;
+            expect(resumed.tasks.map(task => task.id)).toEqual(['S1']);
+            expect(resumed.jobs).toEqual({});
+            expect(resumed.dispatches).toEqual([]);
+            expect(resumed.cycle.nextAction?.actionId).toBe('bootstrap-cycle');
+            expect(resumed.generations).toHaveLength(2);
+            expect(spawned).toBeGreaterThan(0);
+        }
+        finally {
+            cwd.mockRestore();
+            stdout.mockRestore();
+        }
+    });
+    test('CLI requires provider to be asserted, not inherited from the watch default', async () => {
+        const cwd = jest.spyOn(process, 'cwd').mockReturnValue(repo);
+        const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const program = new commander_1.Command();
+        (0, watch_1.registerWatchCommand)(program);
+        try {
+            await program.parseAsync(['node', 'awm', 'watch', 'recover-admission',
+                '--runtime-kind', identity.kind, '--runtime-version', identity.version,
+                '--account-scope-digest', identity.accountScopeDigest, '--controller-autonomy', 'approval-free',
+                '--generation', input.generationToken, '--reason', input.reason]);
+            expect(stderr.mock.calls.map(call => String(call[0])).join('')).toMatch(/--provider/);
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+        }
+        finally {
+            cwd.mockRestore();
+            stderr.mockRestore();
+            process.exitCode = 0;
+        }
+    });
+});

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