agentic-workflow-manager 3.4.0 → 3.5.0

package/dist/tests/commands/watch/apply.test.js

@@ -0,0 +1,397 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const apply_1 = require("../../../src/commands/watch/apply");
+const requests_1 = require("../../../src/core/journal/requests");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const atomicFile = __importStar(require("../../../src/core/atomic-file"));
+const gate_1 = require("../../../src/commands/job/gate");
+function jobPayload(argv) {
+    return { argv, paths: [], cwd: '.', fingerprint: 'fp-1', commandDigest: 'cd-1', expandedPaths: [] };
+}
+function verdictPayload(verdictId, obligationId, result, detail) {
+    return { verdictId, obligationId, result, detail, fingerprint: 'fp-review', argv: ['awm-review', obligationId], paths: [], cwd: '.' };
+}
+describe('aplicacion transaccional de requests', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-apply-')); (0, store_1.initJournal)(repo, 'rama'); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('orden estado->journal->borrado; replay tras crash NO re-aplica (R1.3)', () => {
+        const r1 = (0, requests_1.emitRequest)(repo, 'rama', { kind: 'job-request', generationToken: 'g1', idempotencyKey: 'k1', payload: jobPayload(['npm', 'test']) });
+        const file = r1.file;
+        const savedBody = fs_1.default.readFileSync(file, 'utf8'); // copia para simular crash pre-borrado
+        const out1 = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out1.applied).toBe(1);
+        expect(fs_1.default.existsSync(file)).toBe(false); // borrado DESPUES del journal
+        const s1 = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(Object.keys(s1.jobs)).toHaveLength(1);
+        expect(s1.appliedRequests[r1.requestId].resultRef).toBe(Object.keys(s1.jobs)[0]);
+        // CRASH SIMULADO: el journal persistio pero el archivo NO se borro — lo restauramos
+        fs_1.default.writeFileSync(file, savedBody);
+        const out2 = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out2.applied).toBe(0); // requestId ya registrado: no re-aplica
+        expect(fs_1.default.existsSync(file)).toBe(false); // solo borra
+        expect(Object.keys((0, store_1.readJournal)(repo, 'rama').state.jobs)).toHaveLength(1); // sin duplicados
+    });
+    test('register-entity CREA task con VerificationPlan y ReviewObligations; cycle-plan y dispatch (R1.4/R1.4b)', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: {
+                entity: 'task', taskId: 'T1', title: 'implementar',
+                verificationPlan: [{ id: 'v1', kind: 'test' }],
+                reviewObligations: [{ id: 'o1', kind: 'spec' }],
+            },
+        });
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e2',
+            payload: { entity: 'cycle-plan', items: [{ id: 'cv1', kind: 'qa' }] },
+        });
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e3',
+            payload: { entity: 'dispatch', dispatchId: 'd1', taskId: 'T1' },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.tasks).toHaveLength(1);
+        expect(s.tasks[0].verificationPlan).toEqual([{ id: 'v1', kind: 'test' }]);
+        expect(s.tasks[0].reviewObligations).toEqual([{ id: 'o1', taskId: 'T1', kind: 'spec' }]);
+        expect(s.tasks[0].status).toBe('pending');
+        expect(typeof s.tasks[0].createdAt).toBe('string');
+        expect(s.cycleVerificationPlan).toEqual([{ id: 'cv1', kind: 'qa' }]);
+        expect(s.dispatches).toHaveLength(1);
+        expect(s.tasks[0].attempts).toBe(1); // dispatch real incrementa attempts
+    });
+    test('verdict adverso crea Verdict + FixObligation en la MISMA escritura (R1.4c)', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [], reviewObligations: [{ id: 'o1', kind: 'spec' }] },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const revBefore = (0, store_1.readJournal)(repo, 'rama').state.revision;
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'verdict', generationToken: 'g1', idempotencyKey: 'e2',
+            payload: verdictPayload('verd-1', 'o1', 'fail', 'rompe X'),
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.revision).toBe(revBefore + 1); // UNA escritura para verdict + fix
+        expect(s.verdicts).toHaveLength(1);
+        expect(s.fixes).toEqual([{ id: 'fix-verd-1', verdictId: 'verd-1', closed: false }]);
+        expect(s.tasks[0].reviewObligations[0].verdictId).toBe('verd-1');
+    });
+    test('job-request enlaza satisfies con el item del plan (R1.4c)', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [{ id: 'v1', kind: 'test' }], reviewObligations: [] },
+        });
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'job-request', generationToken: 'g1', idempotencyKey: 'k1',
+            payload: { ...jobPayload(['npm', 'test']), satisfies: 'v1' },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        const jobId = Object.keys(s.jobs)[0];
+        expect(s.tasks[0].verificationPlan[0].satisfiedBy).toBe(jobId);
+        expect(s.jobs[jobId].satisfies).toBe('v1');
+    });
+    test('fencing: token de generacion vieja => rejected-stale-generation auditado (R4.6)', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'controller-heartbeat', generationToken: 'g-vieja', idempotencyKey: 'hb1', payload: {} });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g-nueva');
+        expect(out.rejectedStale).toBe(1);
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(Object.values(s.appliedRequests).some((a) => a.outcome === 'rejected-stale-generation')).toBe(true);
+        expect(s.controllerHeartbeatAt).toBeUndefined();
+    });
+    test('request corrupta se aparta VISIBLE como .corrupt, jamas se descarta (R1.6)', () => {
+        fs_1.default.writeFileSync(path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'req-roto.json'), '{no-json');
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.corrupt).toBe(1);
+        const files = fs_1.default.readdirSync((0, paths_1.requestsDir)(repo, 'rama'));
+        expect(files.some((f) => f.endsWith('.corrupt'))).toBe(true);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.requestProblems).toHaveLength(1);
+        const gate = (0, gate_1.computeGate)(state, false, () => 'fp-1');
+        expect(gate.reasons.some((r) => r.category === 'request-problem')).toBe(true);
+    });
+    test('reutiliza un job mecanicamente identico para dos items sin digest mismatch ni segunda ejecucion', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'task',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [{ id: 'v1', kind: 'test' }, { id: 'v2', kind: 'test' }], reviewObligations: [] },
+        });
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'job-request', generationToken: 'g1', idempotencyKey: 'job:v1',
+            payload: { ...jobPayload(['npm', 'test']), satisfies: 'v1' },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'job-request', generationToken: 'g1', idempotencyKey: 'job:v2',
+            payload: { ...jobPayload(['npm', 'test']), satisfies: 'v2' },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(out.rejectedDigest).toBe(0);
+        expect(Object.keys(state.jobs)).toHaveLength(1);
+        expect(state.tasks[0].verificationPlan.map((item) => item.satisfiedBy)).toEqual([Object.keys(state.jobs)[0], Object.keys(state.jobs)[0]]);
+    });
+    test('un job fallido no se reutiliza como evidencia: una request nueva crea ejecucion nueva', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'job-request', generationToken: 'g1', idempotencyKey: 'k1', payload: jobPayload(['npm', 'test']) });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        let s = (0, store_1.readJournal)(repo, 'rama').state;
+        const failed = Object.values(s.jobs)[0];
+        failed.executionState = 'exited';
+        failed.verdict = 'fail';
+        (0, store_1.writeJournal)(repo, 'rama', s);
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'job-request', generationToken: 'g1', idempotencyKey: 'k2', payload: jobPayload(['npm', 'test']) });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(Object.keys(s.jobs)).toHaveLength(2);
+        expect(Object.values(s.jobs).some((job) => job.executionState === 'received')).toBe(true);
+    });
+    test('kind no reconocido (sintacticamente valido) se trata como corrupt, jamas se descarta en silencio (R1.6)', () => {
+        const r = (0, requests_1.emitRequest)(repo, 'rama', { kind: 'job-request', generationToken: 'g1', idempotencyKey: 'k1', payload: jobPayload(['npm', 'test']) });
+        // simula un kind forward-incompatible/corrupto pero JSON sintacticamente valido
+        const raw = JSON.parse(fs_1.default.readFileSync(r.file, 'utf8'));
+        raw.kind = 'kind-desconocido-xyz';
+        fs_1.default.writeFileSync(r.file, JSON.stringify(raw, null, 2) + '\n');
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out).toEqual({ applied: 0, rejectedStale: 0, rejectedDigest: 0, rejectedInvalid: 0, corrupt: 1 }); // NUNCA "applied: 1" silencioso
+        expect(fs_1.default.existsSync(r.file)).toBe(false); // el .json original ya no esta
+        const files = fs_1.default.readdirSync((0, paths_1.requestsDir)(repo, 'rama'));
+        expect(files.some((f) => f.endsWith('.corrupt'))).toBe(true); // visible, jamas descartado
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.appliedRequests[r.requestId]).toBeUndefined(); // NO se contamina con 'applied'
+        const events = fs_1.default.readFileSync((0, paths_1.eventsPath)(repo, 'rama'), 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+        expect(events.some((e) => e.kind === 'request-corrupt')).toBe(true);
+    });
+    test('batch solo-corrupt igual hace fsync del directorio (durabilidad del rename a .corrupt)', () => {
+        fs_1.default.writeFileSync(path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'req-roto.json'), '{no-json');
+        const spy = jest.spyOn(atomicFile, 'fsyncDirSync');
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.corrupt).toBe(1);
+        expect(spy).toHaveBeenCalledWith((0, paths_1.requestsDir)(repo, 'rama'));
+        spy.mockRestore();
+    });
+    test('si falla la escritura durable, una request corrupta conserva su .json original para replay', () => {
+        const file = path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'req-roto.json');
+        fs_1.default.writeFileSync(file, '{no-json');
+        const spy = jest.spyOn(atomicFile, 'writeFileAtomicDurable').mockImplementationOnce(() => { throw new Error('disk full'); });
+        expect(() => (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1')).toThrow('disk full');
+        expect(fs_1.default.existsSync(file)).toBe(true);
+        expect(fs_1.default.existsSync(`${file}.corrupt`)).toBe(false);
+        spy.mockRestore();
+    });
+    test('shape anidada invalida se rechaza sin mutacion parcial ni journal corrupto', () => {
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'bad-shape',
+            payload: { entity: 'task', taskId: 'T1', verificationPlan: [{ id: 'v1', kind: { nested: true } }], reviewObligations: [] },
+        });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').rejectedInvalid).toBe(1);
+        const read = (0, store_1.readJournal)(repo, 'rama');
+        expect(read.corrupt).toBe(false);
+        expect(read.state.tasks).toHaveLength(0);
+        expect(fs_1.default.existsSync(`${request.file}.rejected`)).toBe(true);
+    });
+    test('verdict para una obligacion inexistente se rechaza en vez de fabricar evidencia', () => {
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'verdict', generationToken: 'g1', idempotencyKey: 'orphan-verdict',
+            payload: verdictPayload('verd-orphan', 'missing', 'pass', 'no existe'),
+        });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').rejectedInvalid).toBe(1);
+        expect((0, store_1.readJournal)(repo, 'rama').state.verdicts).toHaveLength(0);
+        expect(fs_1.default.existsSync(`${request.file}.rejected`)).toBe(true);
+    });
+    // ---- post-implementation-qa: fixes 1-8 (cluster apply.ts/requests.ts/job/index.ts/types.ts) ----
+    test('Fix1: idempotencyKey reutilizada con payload distinto NO tira — se aplica la primera, se rechaza la segunda como rejected-digest-mismatch, sin wedge', () => {
+        const r1 = (0, requests_1.emitRequest)(repo, 'rama', { kind: 'job-request', generationToken: 'g1', idempotencyKey: 'dup-key', payload: jobPayload(['npm', 'test']) });
+        const r2 = (0, requests_1.emitRequest)(repo, 'rama', { kind: 'job-request', generationToken: 'g1', idempotencyKey: 'dup-key', payload: jobPayload(['npm', 'run', 'otro']) });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out).toEqual({ applied: 1, rejectedStale: 0, rejectedDigest: 1, rejectedInvalid: 0, corrupt: 0 });
+        expect(fs_1.default.existsSync(r1.file)).toBe(false);
+        expect(fs_1.default.existsSync(r2.file)).toBe(false);
+        expect(fs_1.default.readdirSync((0, paths_1.requestsDir)(repo, 'rama'))).toHaveLength(0); // nada colgado — jamas wedge
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(Object.keys(s.jobs)).toHaveLength(1);
+        expect(s.appliedRequests[r2.requestId].outcome).toBe('rejected-digest-mismatch');
+        expect(() => (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1')).not.toThrow(); // segunda vuelta: sin re-crash
+    });
+    test('Fix1 Parte C: un error de validacion inesperado en applyRequestToState NO tumba al supervisor — se aparta .rejected, visible, contabilizado', () => {
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task', title: 'sin id' }, // taskId ausente: pasa shape validation, falla la validacion profunda (Fix 6)
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out).toEqual({ applied: 0, rejectedStale: 0, rejectedDigest: 0, rejectedInvalid: 1, corrupt: 0 });
+        expect(fs_1.default.existsSync(r.file)).toBe(false);
+        expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.tasks).toHaveLength(0);
+        expect(s.appliedRequests[r.requestId]).toBeUndefined();
+        const events = fs_1.default.readFileSync((0, paths_1.eventsPath)(repo, 'rama'), 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+        expect(events.some((e) => e.kind === 'request-rejected-invalid')).toBe(true);
+        expect(() => (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1')).not.toThrow();
+    });
+    test('Fix2 (BLOQUEADOR): un veredicto PASS sobre la MISMA obligacion cierra el fix de un veredicto adverso anterior — fail->fix->pass llega a poder certificar', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [], reviewObligations: [{ id: 'o1', kind: 'spec' }] },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'verdict', generationToken: 'g1', idempotencyKey: 'v1',
+            payload: verdictPayload('verd-1', 'o1', 'fail', 'rompe X'),
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const fpNull = () => null;
+        let s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.fixes.find((f) => f.verdictId === 'verd-1').closed).toBe(false);
+        let g = (0, gate_1.computeGate)(s, false, fpNull);
+        expect(g.reasons.some((r) => r.category === 'open-fix')).toBe(true);
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'verdict', generationToken: 'g1', idempotencyKey: 'v2',
+            payload: verdictPayload('verd-2', 'o1', 'pass', 'arreglado'),
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.fixes.find((f) => f.verdictId === 'verd-1').closed).toBe(true); // re-review pass cierra el fix
+        g = (0, gate_1.computeGate)(s, false, fpNull);
+        expect(g.reasons.some((r) => r.category === 'open-fix')).toBe(false); // ya no bloquea por open-fix
+    });
+    test('Fix4: register-entity cycle-plan es idempotente — un re-registro NO pisa el plan existente ni pierde satisfiedBy ya enlazado', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1', payload: { entity: 'cycle-plan', items: [{ id: 'cv1', kind: 'qa' }] } });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'job-request', generationToken: 'g1', idempotencyKey: 'k1', payload: { ...jobPayload(['npm', 'run', 'qa']), satisfies: 'cv1' } });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        let s = (0, store_1.readJournal)(repo, 'rama').state;
+        const jobId = Object.keys(s.jobs)[0];
+        expect(s.cycleVerificationPlan[0].satisfiedBy).toBe(jobId);
+        // re-registro defensivo (ej. tras crash sin memoria de si ya se registro), incluso con items DISTINTOS
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e2', payload: { entity: 'cycle-plan', items: [{ id: 'cv-otro', kind: 'interlock' }] } });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.cycleVerificationPlan).toEqual([{ id: 'cv1', kind: 'qa', satisfiedBy: jobId }]); // plan original preservado
+    });
+    test('Fix5: verdict --detail se redacta antes de persistir en state.json (R2.3)', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [], reviewObligations: [{ id: 'o1', kind: 'spec' }] },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'verdict', generationToken: 'g1', idempotencyKey: 'v1',
+            payload: verdictPayload('verd-1', 'o1', 'fail', 'export API_KEY=abc123secreto'),
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.verdicts[0].detail).toContain('[REDACTED]');
+        expect(s.verdicts[0].detail).not.toContain('abc123secreto');
+    });
+    test('Fix6: register --entity task-status con taskId desconocido NO es fake-success — se rechaza, no crashea', () => {
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task-status', taskId: 'fantasma', status: 'done' },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.rejectedInvalid).toBe(1);
+        expect(out.applied).toBe(0);
+        expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
+    });
+    test('Fix6: register --entity dispatch sin dispatchId se rechaza en vez de coercionar a la string "undefined"', () => {
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'dispatch', taskId: 'T1' }, // dispatchId ausente
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.dispatches).toHaveLength(0);
+        expect(s.dispatches.some((d) => d.id === 'undefined')).toBe(false);
+    });
+    test('Fix7 (R1.4b/R3.6): verificationPlan que no cubre los requiredVerifiers del repo se rechaza EN REGISTRO, no solo en gate', () => {
+        const before = (0, store_1.readJournal)(repo, 'rama').state;
+        before.requiredVerifiers = ['test'];
+        (0, store_1.writeJournal)(repo, 'rama', before);
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [], reviewObligations: [] },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.rejectedInvalid).toBe(1);
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.tasks).toHaveLength(0); // rechazado en registro: jamas llega a existir
+        expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
+    });
+    test('Fix8 (BLOQUEADOR, R1.5): register --entity next-action popula cycle.nextAction; un segundo registro con actionId distinto lo REEMPLAZA libremente', () => {
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'next-action', actionId: 'a1', type: 'implement-task', target: 'T1', preconditions: ['x'], attempt: 1, state: 'in-progress' },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        let s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.cycle.nextAction).toEqual({ actionId: 'a1', type: 'implement-task', target: 'T1', preconditions: ['x'], attempt: 1, state: 'in-progress' });
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e2',
+            payload: { entity: 'next-action', actionId: 'a2', type: 'run-qa', target: 'ciclo' },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        s = (0, store_1.readJournal)(repo, 'rama').state;
+        // libremente sobre-escribible (a diferencia de cycle-plan, Fix4): es el "puntero de resumen" vigente
+        expect(s.cycle.nextAction).toEqual({ actionId: 'a2', type: 'run-qa', target: 'ciclo', preconditions: [], attempt: 0, state: 'pending' });
+    });
+    test('custodia solo se reanuda mediante una decision explicita y auditada', () => {
+        const before = (0, store_1.readJournal)(repo, 'rama').state;
+        before.cycle.status = 'BLOCKED';
+        before.cycle.blockedReason = 'identidad ambigua';
+        before.generations.push({ n: 1, token: 'g1', state: 'active', launchedAt: new Date().toISOString() });
+        (0, store_1.writeJournal)(repo, 'rama', before);
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'resume-1',
+            payload: { entity: 'custody-decision', decision: 'resume', reason: 'operador verifico que no hay llamada en vuelo' },
+        });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.cycle.status).toBe('IN_PROGRESS');
+        expect(s.cycle.blockedReason).toBeUndefined();
+        expect(s.generations[0].state).toBe('superseded');
+        expect(s.custodyDecisions).toEqual([expect.objectContaining({ decision: 'resume', reason: 'operador verifico que no hay llamada en vuelo', generationToken: 'g1' })]);
+    });
+});

package/dist/tests/commands/watch/e2e-crash.test.js

@@ -0,0 +1,157 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const process_1 = require("../../../src/core/journal/process");
+jest.setTimeout(180000);
+const CLI = path_1.default.resolve(__dirname, '..', '..', '..', 'dist', 'src', 'index.js');
+function git(cwd, ...args) {
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', ...args], { cwd });
+}
+function readState(repo) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(repo, '.awm', 'journal', 'main', 'state.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function until(fn, ms = 60000, label = 'condicion') {
+    const t0 = Date.now();
+    while (!fn()) {
+        if (Date.now() - t0 > ms)
+            throw new Error(`timeout esperando ${label}`);
+        await new Promise((r) => setTimeout(r, 200));
+    }
+}
+describe('E2E real: crash/restart del supervisor', () => {
+    let repo;
+    let stubBin;
+    let env;
+    const children = [];
+    beforeAll(() => {
+        if (!fs_1.default.existsSync(CLI))
+            throw new Error('dist ausente: corre `cd cli && npm run build` antes de esta suite (Task 20 Step 1)');
+    });
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-e2e-'));
+        git(repo, 'init', '-q', '-b', 'main');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ name: 'fixture', scripts: { test: 'node -e "process.exit(0)"' } }));
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c');
+        stubBin = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-e2e-bin-'));
+        for (const name of ['codex', 'claude']) {
+            fs_1.default.writeFileSync(path_1.default.join(stubBin, name), '#!/bin/sh\nwhile true; do sleep 1; done\n', { mode: 0o755 });
+        }
+        env = { ...process.env, PATH: `${stubBin}:${process.env.PATH}` };
+        (0, child_process_1.execFileSync)(process.execPath, [CLI, 'watch', '--init'], { cwd: repo, env });
+    });
+    afterEach(() => {
+        // higiene: terminar TODO grupo que hayamos originado (supervisores,
+        // stubs de controlador, wrappers) — cero huerfanos entre tests
+        const s = readState(repo);
+        const groups = new Set();
+        for (const c of children) {
+            if (c.pid !== undefined)
+                groups.add(c.pid);
+        }
+        if (s !== null) {
+            for (const g of s.generations ?? []) {
+                if (g.processRef !== undefined)
+                    groups.add(g.processRef.processGroup);
+            }
+            for (const j of Object.values(s.jobs ?? {})) {
+                if (j.processRef !== undefined)
+                    groups.add(j.processRef.processGroup);
+            }
+        }
+        for (const pgid of groups) {
+            try {
+                process.kill(-pgid, 'SIGKILL');
+            }
+            catch { /* ya muerto */ }
+        }
+        children.length = 0;
+        fs_1.default.rmSync(repo, { recursive: true, force: true });
+        fs_1.default.rmSync(stubBin, { recursive: true, force: true });
+    });
+    function startSupervisor(provider) {
+        const out = fs_1.default.openSync(path_1.default.join(repo, `sup-${children.length}.log`), 'a');
+        const child = (0, child_process_1.spawn)(process.execPath, [CLI, 'watch', '--provider', provider], {
+            cwd: repo, env, detached: true, stdio: ['ignore', out, out],
+        });
+        children.push(child);
+        child.unref();
+        return child;
+    }
+    test('SIGKILL a mitad de job: el wrapper sobrevive, el resultado llega, el restart adopta sin duplicar (R1.8/R4.1/R4.4)', async () => {
+        const sup1 = startSupervisor('codex');
+        const lockPath = path_1.default.join(fs_1.default.realpathSync(repo), '.awm', 'journal', 'supervisor.lock');
+        await until(() => fs_1.default.existsSync(lockPath), 30000, 'lock del supervisor 1');
+        await until(() => {
+            const s = readState(repo);
+            return s !== null && s.generations.some((g) => g.state === 'active');
+        }, 30000, 'generacion activa');
+        const token = readState(repo).generations.find((g) => g.state === 'active').token;
+        // job largo: sobrevive de sobra al SIGKILL del supervisor
+        (0, child_process_1.execFileSync)(process.execPath, [CLI, 'job', 'request', '--generation', token, '--',
+            'node', '-e', 'setTimeout(()=>process.exit(0), 8000)'], { cwd: repo, env });
+        await until(() => {
+            const s = readState(repo);
+            if (s === null)
+                return false;
+            return Object.values(s.jobs).some((j) => j.executionState === 'running');
+        }, 60000, 'job running con identidad real');
+        // CRASH REAL a mitad del job
+        process.kill(sup1.pid, 'SIGKILL');
+        const jobs = readState(repo).jobs;
+        const jobId = Object.keys(jobs)[0];
+        const nonce = jobs[jobId].spawnNonce;
+        const resultFile = path_1.default.join(repo, '.awm', 'journal', 'main', 'logs', `${jobId}.${nonce}.result.json`);
+        // (c) el wrapper EXTERNO sobrevive al supervisor muerto y deja el resultado
+        await until(() => fs_1.default.existsSync(resultFile), 60000, 'result sidecar con supervisor muerto');
+        expect(JSON.parse(fs_1.default.readFileSync(resultFile, 'utf8')).exitCode).toBe(0);
+        // (d) restart: reclama lock muerto y ADOPTA el resultado sin duplicar
+        startSupervisor('codex');
+        await until(() => {
+            const s = readState(repo);
+            if (s === null)
+                return false;
+            const j = s.jobs[jobId];
+            return j !== undefined && j.executionState === 'exited' && j.verdict === 'pass';
+        }, 60000, 'adopcion del resultado');
+        const finalJobs = readState(repo).jobs;
+        expect(Object.keys(finalJobs)).toHaveLength(1); // sin duplicacion
+        expect(Object.values(finalJobs).some((j) => j.attemptOf !== undefined)).toBe(false); // sin attempt fantasma
+    });
+    test('adapter claude-code lanza el stub claude; SIGTERM limpia y libera el lock (R4.8/R2.4)', async () => {
+        const sup = startSupervisor('claude-code');
+        const lockPath = path_1.default.join(fs_1.default.realpathSync(repo), '.awm', 'journal', 'supervisor.lock');
+        await until(() => fs_1.default.existsSync(lockPath), 30000, 'lock');
+        await until(() => {
+            const s = readState(repo);
+            if (s === null)
+                return false;
+            const gen = s.generations.find((g) => g.state === 'active');
+            if (gen?.processRef === undefined)
+                return false;
+            try {
+                const args = (0, child_process_1.execFileSync)('ps', ['-o', 'args=', '-p', String(gen.processRef.pid)], { encoding: 'utf8' });
+                return args.includes('claude');
+            }
+            catch {
+                return false;
+            }
+        }, 30000, 'stub claude lanzado por el adapter');
+        const active = readState(repo).generations.find((g) => g.state === 'active');
+        const controllerRef = active.processRef;
+        process.kill(sup.pid, 'SIGTERM'); // handler de senial: primero drena ownership, luego libera
+        await until(() => !fs_1.default.existsSync(lockPath), 30000, 'lock liberado tras SIGTERM');
+        expect((0, process_1.refIsAlive)(controllerRef)).toBe(false);
+    });
+});