agentic-workflow-manager 3.4.0 → 3.5.0

package/dist/tests/commands/job/gate-reconcile.test.js

@@ -0,0 +1,297 @@
+"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 gate_1 = require("../../../src/commands/job/gate");
+const reconcile_1 = require("../../../src/commands/job/reconcile");
+const reap_1 = require("../../../src/commands/job/reap");
+const types_1 = require("../../../src/core/journal/types");
+function job(partial) {
+    return {
+        id: 'j1', fingerprint: 'fp', commandDigest: 'cd', argv: ['npm', 'test'], cwd: '.',
+        paths: [], expandedPaths: [], executionState: 'received', observationState: 'progressing',
+        phaseTimestamps: {}, ...partial,
+    };
+}
+const fpCurrent = () => 'fp'; // recomputo == persistido => vigente
+const fpStale = () => 'fp-cambiado'; // el arbol cambio => historica
+/** Estado que SATISFACE el gate: task done, plan de task y de ciclo con pass
+ *  vigente, verificador requerido cubierto, cero vivos, cero obligaciones. */
+function passingState() {
+    const s = (0, types_1.emptyState)('r');
+    s.requiredVerifiers = ['test', 'sensors'];
+    s.cycleVerificationPlan = [
+        { id: 'cv1', kind: 'qa', satisfiedBy: 'j2' },
+        { id: 'cv2', kind: 'interlock', satisfiedBy: 'j3' },
+    ];
+    s.tasks.push({
+        id: 'T1', title: 't', status: 'done', attempts: 1,
+        verificationPlan: [
+            { id: 'v1', kind: 'test', satisfiedBy: 'j1' },
+            { id: 'v-sensors', kind: 'sensors', satisfiedBy: 'j4' },
+        ],
+        reviewObligations: [
+            { id: 'o-spec', taskId: 'T1', kind: 'spec', verdictId: 'verd-spec' },
+            { id: 'o-quality', taskId: 'T1', kind: 'quality', verdictId: 'verd-quality' },
+        ],
+    });
+    s.jobs['j1'] = job({ id: 'j1', executionState: 'exited', verdict: 'pass' });
+    s.jobs['j2'] = job({ id: 'j2', executionState: 'exited', verdict: 'pass' });
+    s.jobs['j3'] = job({ id: 'j3', executionState: 'exited', verdict: 'pass' });
+    s.jobs['j4'] = job({ id: 'j4', executionState: 'exited', verdict: 'pass' });
+    s.verdicts.push({ id: 'verd-spec', obligationId: 'o-spec', result: 'pass', detail: 'ok', receivedAt: 'now', fingerprint: 'fp', argv: ['review', 'o-spec'], paths: [], cwd: '.' }, { id: 'verd-quality', obligationId: 'o-quality', result: 'pass', detail: 'ok', receivedAt: 'now', fingerprint: 'fp', argv: ['review', 'o-quality'], paths: [], cwd: '.' });
+    return s;
+}
+describe('gate', () => {
+    test('el estado de referencia pasa; la corrupcion bloquea (R3.2)', () => {
+        expect((0, gate_1.computeGate)(passingState(), false, fpCurrent).pass).toBe(true);
+        const g = (0, gate_1.computeGate)(null, true, fpCurrent);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'corrupt')).toBe(true);
+    });
+    test('CycleVerificationPlan VACIO bloquea — jamas verde por vacuidad (R1.4b)', () => {
+        const s = passingState();
+        s.cycleVerificationPlan = [];
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'empty-cycle-plan')).toBe(true);
+    });
+    test('CycleVerificationPlan exige QA e interlock, no solo cualquier item aprobado (R1.4b/R3.2)', () => {
+        const s = passingState();
+        s.cycleVerificationPlan = s.cycleVerificationPlan.filter((item) => item.kind !== 'interlock');
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'missing-verifier' && /interlock/.test(r.detail))).toBe(true);
+    });
+    test('cada tarea exige obligaciones spec y quality, no certifica por omision', () => {
+        const s = passingState();
+        s.tasks[0].reviewObligations = [];
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.filter((r) => r.category === 'open-obligation')).toHaveLength(2);
+    });
+    test('review pass con fingerprint historico no certifica', () => {
+        const s = passingState();
+        const fingerprintByArgv = (argv) => argv[0] === 'review' ? 'fp-cambiado' : 'fp';
+        const g = (0, gate_1.computeGate)(s, false, fingerprintByArgv);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'stale-fingerprint' && /verd-spec/.test(r.detail))).toBe(true);
+    });
+    test('ausencia de suite o sensors configurados bloquea aunque el plan restante este verde (R3.6)', () => {
+        const s = passingState();
+        s.requiredVerifiers = ['test'];
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'missing-verifier' && /sensors/.test(r.detail))).toBe(true);
+    });
+    test('satisfiedBy colgante (job inexistente) bloquea (R3.2)', () => {
+        const s = passingState();
+        s.tasks[0].verificationPlan[0].satisfiedBy = 'job-fantasma';
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'dangling-reference')).toBe(true);
+    });
+    test('tarea pending o in-progress bloquea (R3.2)', () => {
+        const s = passingState();
+        s.tasks.push({ id: 'T2', title: 'x', status: 'pending', attempts: 0, verificationPlan: [], reviewObligations: [] });
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).reasons.some((r) => r.category === 'pending-task')).toBe(true);
+        s.tasks[1].status = 'in-progress';
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).reasons.some((r) => r.category === 'pending-task')).toBe(true);
+    });
+    test('ciclo BLOCKED bloquea el gate (R3.2)', () => {
+        const s = passingState();
+        s.cycle.status = 'BLOCKED';
+        s.cycle.blockedReason = 'custodia';
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).reasons.some((r) => r.category === 'cycle-blocked')).toBe(true);
+    });
+    test('fingerprint NO vigente => evidencia historica, bloquea (R1.4c, RF-2.8)', () => {
+        const g = (0, gate_1.computeGate)(passingState(), false, fpStale);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'stale-fingerprint')).toBe(true);
+        // recomputo imposible (null) tampoco certifica
+        const g2 = (0, gate_1.computeGate)(passingState(), false, () => null);
+        expect(g2.reasons.some((r) => r.category === 'stale-fingerprint')).toBe(true);
+    });
+    test('solo pass satisface: fail/inconclusive bloquean; sin verdict bloquea (R1.4c)', () => {
+        const s = passingState();
+        s.jobs['j1'].verdict = 'fail';
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).reasons.some((r) => r.category === 'adverse-verdict')).toBe(true);
+        s.jobs['j1'].verdict = 'inconclusive';
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).reasons.some((r) => r.category === 'adverse-verdict')).toBe(true);
+        delete s.jobs['j1'].verdict;
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).reasons.some((r) => r.category === 'adverse-verdict')).toBe(true);
+    });
+    test('item kind review se satisface con VERDICT pass, no con job (R1.4c)', () => {
+        const s = passingState();
+        s.tasks[0].verificationPlan.push({ id: 'v2', kind: 'review', satisfiedBy: 'verd-1' });
+        s.verdicts.push({ id: 'verd-1', obligationId: 'o1', result: 'pass', detail: 'ok', receivedAt: 'now', fingerprint: 'fp', argv: ['review', 'o1'], paths: [], cwd: '.' });
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).pass).toBe(true);
+        s.verdicts[0].result = 'fail';
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent);
+        expect(g.reasons.some((r) => r.category === 'adverse-verdict')).toBe(true);
+        expect(g.reasons.some((r) => r.category === 'open-fix')).toBe(true); // adverso sin fix cerrado
+    });
+    test('item sin satisfacer, job vivo, orphaned y obligacion abierta bloquean (R3.2, R4.5)', () => {
+        const s = passingState();
+        s.tasks[0].verificationPlan.push({ id: 'v3', kind: 'sensors' });
+        expect((0, gate_1.computeGate)(s, false, fpCurrent).reasons.some((r) => r.category === 'unsatisfied-plan')).toBe(true);
+        const s2 = passingState();
+        s2.jobs['vivo'] = job({ id: 'vivo', executionState: 'running' });
+        expect((0, gate_1.computeGate)(s2, false, fpCurrent).reasons.some((r) => r.category === 'live-job')).toBe(true);
+        s2.jobs['vivo'].executionState = 'orphaned';
+        expect((0, gate_1.computeGate)(s2, false, fpCurrent).reasons.some((r) => r.category === 'live-job')).toBe(true);
+        const s3 = passingState();
+        s3.tasks[0].reviewObligations.push({ id: 'o9', taskId: 'T1', kind: 'spec' });
+        expect((0, gate_1.computeGate)(s3, false, fpCurrent).reasons.some((r) => r.category === 'open-obligation')).toBe(true);
+    });
+    test('verificador requerido por el repo sin item en ningun plan bloquea (R1.4b, R3.6)', () => {
+        const s = passingState();
+        s.tasks[0].verificationPlan = s.tasks[0].verificationPlan.filter((item) => item.kind !== 'sensors');
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent); // ningun item kind 'sensors' existe
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'missing-verifier' && /sensors/.test(r.detail))).toBe(true);
+    });
+    test('reviewObligation con verdictId colgante o adverso bloquea, no solo si esta ausente (R3.2, R1.4c)', () => {
+        const s = passingState();
+        s.tasks[0].reviewObligations.push({ id: 'o1', taskId: 'T1', kind: 'spec', verdictId: 'verd-fantasma' });
+        const g = (0, gate_1.computeGate)(s, false, fpCurrent);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'dangling-reference')).toBe(true);
+        const s2 = passingState();
+        s2.verdicts.push({ id: 'verd-2', obligationId: 'o2', result: 'fail', detail: 'no', receivedAt: 'now', fingerprint: 'fp', argv: ['review', 'o2'], paths: [], cwd: '.' });
+        s2.tasks[0].reviewObligations.push({ id: 'o2', taskId: 'T1', kind: 'spec', verdictId: 'verd-2' });
+        const g2 = (0, gate_1.computeGate)(s2, false, fpCurrent);
+        expect(g2.pass).toBe(false);
+        expect(g2.reasons.some((r) => r.category === 'adverse-verdict')).toBe(true);
+    });
+});
+describe('reconcile — matriz unica R1.8 (R3.3)', () => {
+    let logs;
+    beforeEach(() => { logs = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rec-')); });
+    afterEach(() => { fs_1.default.rmSync(logs, { recursive: true, force: true }); });
+    test('sin claim => reintenta mismo intent; claim+resultado => adoptar; claim sin resultado => orphaned', () => {
+        const s = (0, types_1.emptyState)('r');
+        const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'n1', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        s.jobs['a'] = job({ id: 'a', executionState: 'spawn-intent', spawnNonce: 'nA', processRef: { ...deadRef, spawnNonce: 'nA' } });
+        s.jobs['b'] = job({ id: 'b', executionState: 'running', spawnNonce: 'nB', processRef: { ...deadRef, spawnNonce: 'nB' } });
+        s.jobs['c'] = job({ id: 'c', executionState: 'running', spawnNonce: 'nC', processRef: { ...deadRef, spawnNonce: 'nC' } });
+        // b: claim + resultado => adoptar
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'b.nB.claim'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'b.nB.result.json'), JSON.stringify({ exitCode: 0, endedAt: 'x', resultPath: 'p' }));
+        // c: claim sin resultado => orphaned
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'c.nC.claim'), '{}');
+        const out = (0, reconcile_1.reconcileJobs)(s, logs);
+        expect(out.decisions.find((d) => d.jobId === 'a').action).toBe('retry-same-intent');
+        expect(out.decisions.find((d) => d.jobId === 'b').action).toBe('adopt-result');
+        expect(s.jobs['b'].executionState).toBe('exited');
+        expect(s.jobs['b'].verdict).toBe('pass');
+        expect(out.decisions.find((d) => d.jobId === 'c').action).toBe('orphaned-authorization-required');
+        expect(s.jobs['c'].executionState).toBe('orphaned');
+    });
+    test('materializeRetry crea Attempt NUEVO enlazado, nunca reutiliza (R1.7)', () => {
+        const s = (0, types_1.emptyState)('r');
+        s.jobs['a'] = job({ id: 'a', executionState: 'spawn-intent', spawnNonce: 'nA' });
+        s.tasks.push({ id: 'T1', title: 't', status: 'in-progress', attempts: 1,
+            verificationPlan: [{ id: 'v1', kind: 'test', satisfiedBy: 'a' }], reviewObligations: [] });
+        s.cycleVerificationPlan.push({ id: 'cv1', kind: 'qa', satisfiedBy: 'a' });
+        const nuevo = (0, reconcile_1.materializeRetry)(s, 'a');
+        expect(s.jobs['a'].executionState).toBe('cancelled'); // el intento viejo se retira
+        expect(nuevo.attemptOf).toBe('a');
+        expect(nuevo.executionState).toBe('received');
+        expect(nuevo.spawnNonce).toBeUndefined(); // nonce fresco lo asigna el runner
+        expect(s.jobs[nuevo.id]).toBe(nuevo);
+        expect(s.tasks[0].verificationPlan[0].satisfiedBy).toBe(nuevo.id);
+        expect(s.cycleVerificationPlan[0].satisfiedBy).toBe(nuevo.id);
+    });
+    test('claim+resultado con forma invalida (JSON valido pero sin exitCode numerico) => orphaned, jamas fabricar verdict (R1.6)', () => {
+        const s = (0, types_1.emptyState)('r');
+        const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'nD', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        s.jobs['d'] = job({ id: 'd', executionState: 'running', spawnNonce: 'nD', processRef: { ...deadRef, spawnNonce: 'nD' } });
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'd.nD.claim'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'd.nD.result.json'), JSON.stringify({})); // sin exitCode: forma invalida
+        const out = (0, reconcile_1.reconcileJobs)(s, logs);
+        expect(out.decisions.find((d) => d.jobId === 'd').action).toBe('orphaned-authorization-required');
+        expect(s.jobs['d'].executionState).toBe('orphaned');
+        expect(s.jobs['d'].verdict).toBeUndefined(); // jamas fabricado de un sidecar sin forma
+    });
+    test('claim+resultado con JSON invalido (parse error) => orphaned, no crashea (R1.6)', () => {
+        const s = (0, types_1.emptyState)('r');
+        const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'nE', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        s.jobs['e'] = job({ id: 'e', executionState: 'running', spawnNonce: 'nE', processRef: { ...deadRef, spawnNonce: 'nE' } });
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'e.nE.claim'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'e.nE.result.json'), '{ esto no es json valido');
+        let out;
+        expect(() => { out = (0, reconcile_1.reconcileJobs)(s, logs); }).not.toThrow();
+        expect(out.decisions.find((d) => d.jobId === 'e').action).toBe('orphaned-authorization-required');
+        expect(s.jobs['e'].executionState).toBe('orphaned');
+    });
+    test('adopt-result respalda spawnNonce resuelto via processRef, para que la evidencia siga siendo observable (R1.3, RNF-T.9)', () => {
+        const s = (0, types_1.emptyState)('r');
+        const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'nR', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        s.jobs['r1'] = job({ id: 'r1', executionState: 'running', processRef: deadRef }); // spawnNonce propio ausente adrede
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'r1.nR.claim'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'r1.nR.result.json'), JSON.stringify({ exitCode: 0, endedAt: 'x', resultPath: 'p' }));
+        (0, reconcile_1.reconcileJobs)(s, logs);
+        expect(s.jobs['r1'].spawnNonce).toBe('nR');
+        expect(s.jobs['r1'].executionState).toBe('exited');
+    });
+});
+describe('reap — limpieza explicita con identidad validada (R2.2)', () => {
+    test('planReap reporta aliveWithIdentity via refIsAlive, solo para jobs con processRef', () => {
+        const s = (0, types_1.emptyState)('r');
+        const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'n1', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        s.jobs['sinRef'] = job({ id: 'sinRef', executionState: 'running' });
+        s.jobs['muerto'] = job({ id: 'muerto', executionState: 'running', processRef: deadRef });
+        const plan = (0, reap_1.planReap)(s);
+        expect(plan.find((p) => p.jobId === 'sinRef')).toBeUndefined();
+        const m = plan.find((p) => p.jobId === 'muerto');
+        expect(m.pid).toBe(999999);
+        expect(m.aliveWithIdentity).toBe(false);
+    });
+    test('planReap reporta aliveWithIdentity: true para un proceso genuinamente vivo', () => {
+        const { spawnStructured } = require('../../../src/core/journal/process');
+        const s = (0, types_1.emptyState)('r');
+        const { child, ref } = spawnStructured(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nLive');
+        s.jobs['vivo'] = job({ id: 'vivo', executionState: 'running', processRef: ref });
+        try {
+            const plan = (0, reap_1.planReap)(s);
+            const m = plan.find((p) => p.jobId === 'vivo');
+            expect(m.pid).toBe(ref.pid);
+            expect(m.aliveWithIdentity).toBe(true);
+        }
+        finally {
+            child.kill('SIGKILL');
+        }
+    });
+    test('executeReap nunca señaliza sin processRef ni sin identidad viva confirmada (R2.1, R2.2)', async () => {
+        const s = (0, types_1.emptyState)('r');
+        const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'n1', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        s.jobs['sinRef'] = job({ id: 'sinRef', executionState: 'running' });
+        s.jobs['muerto'] = job({ id: 'muerto', executionState: 'running', processRef: deadRef });
+        const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => true);
+        try {
+            const killed = await (0, reap_1.executeReap)(s, ['sinRef', 'muerto', 'no-existe']);
+            expect(killed).toEqual([]);
+            // no solo el resultado: nunca se INTENTO ninguna señal (R2.1) —
+            // la ausencia de identidad viva confirmada corta antes de llamar
+            // a terminateGroupConfirmed/process.kill, no despues.
+            expect(killSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            killSpy.mockRestore();
+        }
+    });
+    test('executeReap mata y reporta solo jobs con muerte confirmada', async () => {
+        const { spawnStructured } = require('../../../src/core/journal/process');
+        const s = (0, types_1.emptyState)('r');
+        const { child, ref } = spawnStructured(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nX');
+        s.jobs['vivo'] = job({ id: 'vivo', executionState: 'running', processRef: ref });
+        const killed = await (0, reap_1.executeReap)(s, ['vivo']);
+        expect(killed).toEqual(['vivo']);
+        child.kill('SIGKILL');
+    });
+});

package/dist/tests/commands/job/reap-cli.test.js

@@ -0,0 +1,101 @@
+"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 commander_1 = require("commander");
+const job_1 = require("../../../src/commands/job");
+const store_1 = require("../../../src/core/journal/store");
+// CLI-level wiring de `job reap` (Gap 2 del post-implementation-qa): las
+// funciones puras planReap/executeReap ya estan cubiertas en
+// gate-reconcile.test.ts — esto prueba el comando REGISTRADO: (a) --execute
+// sin --jobs falla con un mensaje claro, no un stack trace crudo; (b) el plan
+// SIEMPRE se imprime antes de cualquier ejecucion (R2.2).
+function gitInit(repo) {
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'init', '-q', '-b', 'rama'], { cwd: repo });
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'add', '.'], { cwd: repo });
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-qm', 'c'], { cwd: repo });
+}
+function job(partial) {
+    return {
+        id: 'j1', fingerprint: 'fp', commandDigest: 'cd', argv: ['npm', 'test'], cwd: '.',
+        paths: [], expandedPaths: [], executionState: 'running', observationState: 'progressing',
+        phaseTimestamps: {}, ...partial,
+    };
+}
+async function run(argv, cwd) {
+    const prog = new commander_1.Command();
+    prog.exitOverride();
+    (0, job_1.registerJobCommand)(prog);
+    const spy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    const cwdSpy = jest.spyOn(process, 'cwd').mockReturnValue(cwd);
+    let error = null;
+    try {
+        await prog.parseAsync(['node', 'awm', 'job', ...argv]);
+    }
+    catch (e) {
+        error = e;
+    }
+    finally {
+        cwdSpy.mockRestore();
+    }
+    const out = spy.mock.calls.map((c) => String(c[0])).join('');
+    spy.mockRestore();
+    return { out, error };
+}
+describe('awm job reap CLI wiring (R2.2)', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-reap-cli-'));
+        gitInit(repo);
+        (0, store_1.initJournal)(repo, 'rama');
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        // job sin processRef: excluido del plan (planReap solo reporta jobs con processRef)
+        s.jobs['sinRef'] = job({ id: 'sinRef' });
+        // job con processRef de un pid que ya no existe: aliveWithIdentity: false
+        s.jobs['muerto'] = job({
+            id: 'muerto',
+            processRef: { pid: 999999, startTime: 'gone', spawnNonce: 'n1', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' },
+        });
+        (0, store_1.writeJournal)(repo, 'rama', s);
+    });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('`job reap` sin --execute imprime el plan a stdout y no ejecuta nada', async () => {
+        const { out, error } = await run(['reap'], repo);
+        expect(error).toBeNull();
+        const plan = JSON.parse(out);
+        expect(Array.isArray(plan)).toBe(true);
+        // solo el job con processRef aparece
+        expect(plan).toHaveLength(1);
+        expect(plan[0]).toMatchObject({ jobId: 'muerto', pid: 999999, aliveWithIdentity: false });
+        // no se imprimio un segundo bloque {killed: ...} — no hubo ejecucion
+        expect(out).not.toContain('killed');
+    });
+    test('`job reap --execute` sin --jobs falla con un error claro, no un stack trace crudo', async () => {
+        const { out, error } = await run(['reap', '--execute'], repo);
+        expect(error).not.toBeNull();
+        expect(error.message).toMatch(/--execute requiere --jobs/);
+        // R2.2: el plan se imprimio ANTES de que la falta de --jobs abortara la ejecucion
+        const plan = JSON.parse(out);
+        expect(Array.isArray(plan)).toBe(true);
+        expect(plan).toHaveLength(1);
+    });
+    test('`job reap --execute --jobs <id>` imprime el plan primero y luego el resultado de la ejecucion', async () => {
+        const { out, error } = await run(['reap', '--execute', '--jobs', 'muerto'], repo);
+        expect(error).toBeNull();
+        // dos bloques JSON concatenados: el plan, despues {killed:[...]}
+        const planEndIdx = out.indexOf('\n]\n') + 3;
+        const planPart = out.slice(0, planEndIdx);
+        const resultPart = out.slice(planEndIdx);
+        const plan = JSON.parse(planPart);
+        expect(plan).toHaveLength(1);
+        const result = JSON.parse(resultPart);
+        // identidad muerta => nunca se envio senial, killed vacio (R2.1)
+        expect(result).toEqual({ killed: [] });
+    });
+});

package/dist/tests/commands/job/verbs.test.js

@@ -0,0 +1,56 @@
+"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 request_1 = require("../../../src/commands/job/request");
+const heartbeat_1 = require("../../../src/commands/job/heartbeat");
+const query_1 = require("../../../src/commands/job/query");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const requests_1 = require("../../../src/core/journal/requests");
+function gitInit(repo) {
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'init', '-q'], { cwd: repo });
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'add', '.'], { cwd: repo });
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-qm', 'c'], { cwd: repo });
+}
+describe('job verbs', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-verbs-')); gitInit(repo); (0, store_1.initJournal)(repo, 'rama'); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('requestJob emite request con get-or-create key = hash(fingerprint+cmd) y cwd real (R3.1)', () => {
+        const a = (0, request_1.requestJob)(repo, 'rama', 'gen-1', ['npm', 'test'], [], '.');
+        const b = (0, request_1.requestJob)(repo, 'rama', 'gen-1', ['npm', 'test'], [], '.');
+        expect(a.idempotencyKey).toBe(b.idempotencyKey); // mismo fingerprint+cmd => misma key (RNF-T.7)
+        fs_1.default.mkdirSync(path_1.default.join(repo, 'otro-cwd-logico'));
+        const c = (0, request_1.requestJob)(repo, 'rama', 'gen-1', ['npm', 'test'], [], 'otro-cwd-logico');
+        expect(c.idempotencyKey).not.toBe(a.idempotencyKey); // cwd distinto => key distinta (R3.4)
+        expect((0, requests_1.listPendingRequests)(repo, 'rama').length).toBe(3); // el supervisor colapsa por key
+    });
+    test('emitHeartbeat publica request de heartbeat (R3.5)', () => {
+        (0, heartbeat_1.emitHeartbeat)(repo, 'rama', 'gen-1');
+        const pending = (0, requests_1.listPendingRequests)(repo, 'rama');
+        expect(pending.some((p) => !p.corrupt && p.envelope.kind === 'controller-heartbeat')).toBe(true);
+    });
+    test('queryPs/list/show reportan corrupt visible, no lo descartan (R1.6)', () => {
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        s.jobs['j1'] = {
+            id: 'j1', fingerprint: 'fp', commandDigest: 'cd', argv: ['npm', 'test'], cwd: '.',
+            paths: [], expandedPaths: [], executionState: 'received', observationState: 'progressing', phaseTimestamps: {},
+        };
+        (0, store_1.writeJournal)(repo, 'rama', s);
+        expect((0, query_1.queryPs)(repo, 'rama').corruptState).toBe(false);
+        expect((0, query_1.queryList)(repo, 'rama').jobs).toHaveLength(1);
+        expect((0, query_1.queryShow)(repo, 'rama', 'j1').job.id).toBe('j1');
+        expect((0, query_1.queryShow)(repo, 'rama', 'no-existe').job).toBeNull();
+        fs_1.default.writeFileSync((0, paths_1.statePath)(repo, 'rama'), '{roto');
+        expect((0, query_1.queryPs)(repo, 'rama').corruptState).toBe(true);
+        expect((0, query_1.queryList)(repo, 'rama').corruptState).toBe(true);
+        expect((0, query_1.queryShow)(repo, 'rama', 'j1').corruptState).toBe(true);
+    });
+});

package/dist/tests/commands/job/verdict-determinism.test.js

@@ -0,0 +1,138 @@
+"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 commander_1 = require("commander");
+const job_1 = require("../../../src/commands/job");
+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");
+// Fix 3 (post-implementation-qa): `job verdict`'s verdictId era
+// Date.now()+random en cada invocacion aunque idempotencyKey ya era
+// determinista — un retry legitimo del MISMO comando producia un payload
+// distinto (verdictId distinto => payloadDigest distinto) y, tras Fix 1,
+// caia a rejected-digest-mismatch en vez de reconocerse como el mismo alias.
+// Esto prueba el comando CLI REGISTRADO (no la logica interna de apply.ts):
+// invocaciones identicas producen el MISMO verdictId, byte-identico.
+function gitInit(repo) {
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'init', '-q', '-b', 'rama'], { cwd: repo });
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'add', '.'], { cwd: repo });
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-qm', 'c'], { cwd: repo });
+}
+async function run(argv, cwd) {
+    const prog = new commander_1.Command();
+    prog.exitOverride();
+    (0, job_1.registerJobCommand)(prog);
+    const spy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    const cwdSpy = jest.spyOn(process, 'cwd').mockReturnValue(cwd);
+    let error = null;
+    try {
+        await prog.parseAsync(['node', 'awm', 'job', ...argv]);
+    }
+    catch (e) {
+        error = e;
+    }
+    finally {
+        cwdSpy.mockRestore();
+    }
+    const out = spy.mock.calls.map((c) => String(c[0])).join('');
+    spy.mockRestore();
+    return { out, error };
+}
+describe('`job verdict` verdictId determinista (Fix 3)', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-verdict-cli-'));
+        gitInit(repo);
+        (0, store_1.initJournal)(repo, 'rama');
+    });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('dos invocaciones identicas producen el MISMO verdictId', async () => {
+        const args = ['verdict', '--generation', 'g1', '--obligation', 'o1', '--result', 'fail', '--detail', 'rompe X'];
+        const a = await run(args, repo);
+        const b = await run(args, repo);
+        expect(a.error).toBeNull();
+        expect(b.error).toBeNull();
+        const verdictIdA = JSON.parse(a.out).verdictId;
+        const verdictIdB = JSON.parse(b.out).verdictId;
+        expect(verdictIdA).toBe(verdictIdB);
+        // ademas: mismo idempotencyKey Y mismo payloadDigest (byte-identico) para
+        // ambas requests emitidas — un retry real, no un digest-mismatch espurio.
+        const pending = (0, requests_1.listPendingRequests)(repo, 'rama').filter((p) => !p.corrupt);
+        expect(pending).toHaveLength(2);
+        expect(pending[0].envelope.idempotencyKey).toBe(pending[1].envelope.idempotencyKey);
+        expect(JSON.stringify(pending[0].envelope.payload)).toBe(JSON.stringify(pending[1].envelope.payload));
+    });
+    test('generation distinta produce un verdictId distinto (evita colision entre generaciones)', async () => {
+        const a = await run(['verdict', '--generation', 'g1', '--obligation', 'o1', '--result', 'fail', '--detail', 'x'], repo);
+        const b = await run(['verdict', '--generation', 'g2', '--obligation', 'o1', '--result', 'fail', '--detail', 'x'], repo);
+        expect(JSON.parse(a.out).verdictId).not.toBe(JSON.parse(b.out).verdictId);
+    });
+});
+// Regresion adversarial reviewer (post-624a4c0): 624a4c0 hizo verdictId
+// generation-scoped pero DEJO idempotencyKey sin generation. Como
+// payloadDigest se computa sobre TODO el payload (que embebe verdictId), un
+// segundo veredicto con MISMA obligacion/result/detail pero OTRA generation
+// (ej. controller crasheo y relanzo con nuevo generationToken entre dos
+// submits — ver watch/generations.ts beginGeneration, esto pasa en CADA
+// relanzamiento) produce: MISMA idempotencyKey (no incluia generation) pero
+// payloadDigest DISTINTO (verdictId si difiere) => cae al chequeo proactivo
+// de Fix 1 en consumePendingRequests y se rechaza como
+// rejected-digest-mismatch en vez de aplicarse como el veredicto
+// genuinamente nuevo y distinto que en realidad es — socavando directamente
+// Fix 2 (cierre de FixObligation en re-review pass) si el pass llega bajo
+// otra generation que el fail original.
+describe('verdict idempotencyKey alineada en scope con verdictId (regresion adversarial reviewer)', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-verdict-scope-'));
+        gitInit(repo);
+        (0, store_1.initJournal)(repo, 'rama');
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'reg-e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [], reviewObligations: [{ id: 'o1', kind: 'spec' }] },
+        });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g0');
+    });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('ESCENARIO EXACTO del reviewer: fail bajo g1 abre un fix que bloquea el gate; el MISMO veredicto (obligacion/result/detail) reenviado bajo g2 se APLICA, no se rechaza por digest-mismatch', async () => {
+        const fpNull = () => null;
+        const a = await run(['verdict', '--generation', 'g1', '--obligation', 'o1', '--result', 'fail', '--detail', 'rompe X'], repo);
+        expect(a.error).toBeNull();
+        const out1 = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out1).toEqual({ applied: 1, rejectedStale: 0, rejectedDigest: 0, rejectedInvalid: 0, corrupt: 0 });
+        let s = (0, store_1.readJournal)(repo, 'rama').state;
+        const verdictIdFail = JSON.parse(a.out).verdictId;
+        expect(s.fixes.find((f) => f.verdictId === verdictIdFail).closed).toBe(false);
+        expect((0, gate_1.computeGate)(s, false, fpNull).reasons.some((r) => r.category === 'open-fix')).toBe(true);
+        // controller crashea y relanza (beginGeneration produce un token nuevo) —
+        // reenvia el MISMO veredicto (misma obligacion/result/detail) bajo g2.
+        const b = await run(['verdict', '--generation', 'g2', '--obligation', 'o1', '--result', 'fail', '--detail', 'rompe X'], repo);
+        expect(b.error).toBeNull();
+        const out2 = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g2');
+        expect(out2.rejectedDigest).toBe(0); // <- ANTES del fix: esto era 1 (rejected-digest-mismatch espurio)
+        expect(out2).toEqual({ applied: 1, rejectedStale: 0, rejectedDigest: 0, rejectedInvalid: 0, corrupt: 0 });
+        s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.verdicts).toHaveLength(2); // el segundo veredicto, genuinamente distinto, quedo registrado
+    });
+    test('un veredicto PASS reenviado bajo OTRA generation que el fail original sigue cerrando el fix (Fix2 sobrevive al alineado de scope)', async () => {
+        const fpNull = () => null;
+        const a = await run(['verdict', '--generation', 'g1', '--obligation', 'o1', '--result', 'fail', '--detail', 'rompe X'], repo);
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const verdictIdFail = JSON.parse(a.out).verdictId;
+        const b = await run(['verdict', '--generation', 'g2', '--obligation', 'o1', '--result', 'pass', '--detail', 'arreglado'], repo);
+        expect(b.error).toBeNull();
+        const out2 = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g2');
+        expect(out2).toEqual({ applied: 1, rejectedStale: 0, rejectedDigest: 0, rejectedInvalid: 0, corrupt: 0 });
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.fixes.find((f) => f.verdictId === verdictIdFail).closed).toBe(true);
+        expect((0, gate_1.computeGate)(s, false, fpNull).reasons.some((r) => r.category === 'open-fix')).toBe(false);
+    });
+});