agentic-workflow-manager 3.3.1 → 3.5.0

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

@@ -0,0 +1,115 @@
+"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 generations_1 = require("../../../src/commands/watch/generations");
+const adapter_1 = require("../../../src/core/journal/adapter");
+const process_1 = require("../../../src/core/journal/process");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+describe('generaciones', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-gen-')); (0, store_1.initJournal)(repo, 'rama'); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('decideStall: heartbeat vencido solo => observar, nunca kill (R4.2)', () => {
+        const cfg = { heartbeatTimeoutMs: 5 * 60000, activityWindowMs: 10 * 60000 };
+        expect((0, generations_1.decideStall)({ heartbeatAgeMs: 60000, activityFrozenMs: 0, safeToReplace: 'indeterminate' }, cfg)).toBe('healthy');
+        expect((0, generations_1.decideStall)({ heartbeatAgeMs: 10 * 60000, activityFrozenMs: 0, safeToReplace: 'indeterminate' }, cfg)).toBe('suspected-stall-observe');
+        // doble senial + adapter indeterminate => custodia BLOCKED, sin matar (R4.2b)
+        expect((0, generations_1.decideStall)({ heartbeatAgeMs: 20 * 60000, activityFrozenMs: 15 * 60000, safeToReplace: 'indeterminate' }, cfg)).toBe('custody-blocked');
+        // doble senial + safe positivo => recien ahi resolver la generacion
+        expect((0, generations_1.decideStall)({ heartbeatAgeMs: 20 * 60000, activityFrozenMs: 15 * 60000, safeToReplace: 'safe' }, cfg)).toBe('resolve-generation');
+    });
+    test('backoff 1->5->15 con techo y tope por hora (R4.3)', () => {
+        const b = new generations_1.Backoff();
+        expect(b.nextMs()).toBe(60000);
+        expect(b.nextMs()).toBe(300000);
+        expect(b.nextMs()).toBe(900000);
+        expect(b.nextMs()).toBe(900000); // techo
+        expect(b.exhausted()).toBe(false);
+        for (let i = 0; i < 6; i++)
+            b.recordRelaunch();
+        expect(b.exhausted()).toBe(true);
+    });
+    test('beginGeneration hace fencing: la anterior queda superseded (R1.7)', () => {
+        const g1 = (0, generations_1.beginGeneration)(repo, 'rama');
+        const g2 = (0, generations_1.beginGeneration)(repo, 'rama');
+        expect(g2.n).toBe(2);
+        expect(g2.token).not.toBe(g1.token);
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.generations.find((g) => g.n === 1).state).toBe('superseded');
+        expect((0, generations_1.activeGeneration)(s).n).toBe(2);
+    });
+    test('beginGeneration reinicia el heartbeat al cambiar el fencing token', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.controllerHeartbeatAt = new Date().toISOString();
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        expect((0, store_1.readJournal)(repo, 'rama').state.controllerHeartbeatAt).toBeUndefined();
+    });
+    test('el intent de launch queda durable y el prompt entrega el generation token al controller', () => {
+        const begun = (0, generations_1.beginGeneration)(repo, 'rama');
+        let captured;
+        const wrapperRef = { pid: 42, startTime: 't', spawnNonce: 'wrapper-nonce', argvDigest: 'a', processGroup: 42, psArgsDigest: 'p' };
+        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', 'continua el ciclo', (job, nonce) => {
+            const duringSpawn = (0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'rama').state);
+            expect(duringSpawn.controllerJobId).toBe(job.id); // persistido ANTES del spawn
+            expect(duringSpawn.spawnNonce).toBe(nonce);
+            captured = { argv: job.argv, nonce };
+            return wrapperRef;
+        });
+        expect(captured.argv.join(' ')).toContain(begun.token);
+        expect(captured.argv.join(' ')).toContain(`--generation ${begun.token}`);
+        expect((0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'rama').state).wrapperRef).toEqual(wrapperRef);
+    });
+    test('claim sin identidad/resultado conserva ownership ambiguo; usa la edad del claim, no la de begin', () => {
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', 'continua', () => { });
+        let s = (0, store_1.readJournal)(repo, 'rama').state;
+        const gen = (0, generations_1.activeGeneration)(s);
+        gen.launchedAt = new Date(Date.now() - 3600000).toISOString();
+        (0, store_1.writeJournal)(repo, 'rama', s);
+        fs_1.default.mkdirSync((0, paths_1.logsDir)(repo, 'rama'), { recursive: true });
+        fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'rama'), gen.controllerJobId, gen.spawnNonce), '{}');
+        expect((0, generations_1.controllerGenerationHasUnresolvedClaim)(repo, 'rama', gen)).toBe(true);
+        (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', 'continua', () => { }, 10000);
+        expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('IN_PROGRESS'); // claim recien creado: aun dentro de gracia
+        const old = new Date(Date.now() - 20000);
+        fs_1.default.utimesSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'rama'), gen.controllerJobId, gen.spawnNonce), old, old);
+        (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', 'continua', () => { }, 10000);
+        expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('BLOCKED');
+        fs_1.default.writeFileSync((0, exec_wrapper_1.resultPath)((0, paths_1.logsDir)(repo, 'rama'), gen.controllerJobId, gen.spawnNonce), JSON.stringify({ exitCode: 1 }));
+        expect((0, generations_1.controllerGenerationHasUnresolvedClaim)(repo, 'rama', gen)).toBe(false);
+    });
+    test('resolveGeneration: muerte probada => proven-dead; vivo+indeterminate => custodia con estado BLOCKED (R4.2b)', async () => {
+        const adapter = (0, adapter_1.adapterFor)('codex');
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        let s = (0, store_1.readJournal)(repo, 'rama').state;
+        const gen = (0, generations_1.activeGeneration)(s);
+        gen.processRef = { pid: 999999, startTime: 'gone', spawnNonce: 'n', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        (0, store_1.writeJournal)(repo, 'rama', s);
+        expect(await (0, generations_1.resolveGeneration)(repo, 'rama', adapter, { termGraceMs: 100, killGraceMs: 100 })).toBe('proven-dead');
+        // vivo: el adapter codex no puede afirmar safeToReplace => custodia SIN matar
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 8000)'], process.cwd(), 'nG');
+        s = (0, store_1.readJournal)(repo, 'rama').state;
+        (0, generations_1.activeGeneration)(s).processRef = ref;
+        (0, store_1.writeJournal)(repo, 'rama', s);
+        expect(await (0, generations_1.resolveGeneration)(repo, 'rama', adapter, { termGraceMs: 100, killGraceMs: 100 })).toBe('custody-blocked');
+        const after = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(after.cycle.status).toBe('BLOCKED');
+        expect(after.cycle.blockedReason).toMatch(/safeToReplace/);
+        expect(child.killed).toBe(false); // JAMAS se toco al vivo
+        child.kill('SIGKILL');
+    });
+    test('enterCustody deja razon auditada y ciclo BLOCKED (R4.5)', () => {
+        (0, generations_1.enterCustody)(repo, 'rama', 'prueba de custodia');
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.cycle.status).toBe('BLOCKED');
+        expect(s.cycle.blockedReason).toBe('prueba de custodia');
+    });
+});

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

@@ -0,0 +1,124 @@
+"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 apply_1 = require("../../../src/commands/watch/apply");
+const runner_1 = require("../../../src/commands/watch/runner");
+const generations_1 = require("../../../src/commands/watch/generations");
+const init_1 = require("../../../src/commands/watch/init");
+const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+const gate_1 = require("../../../src/commands/job/gate");
+const reconcile_1 = require("../../../src/commands/job/reconcile");
+const request_1 = require("../../../src/commands/job/request");
+const fingerprint_1 = require("../../../src/core/journal/fingerprint");
+const requests_1 = require("../../../src/core/journal/requests");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+jest.setTimeout(30000);
+const fakeSpawner = (job, nonce, logsRoot, repoRoot) => {
+    void (0, exec_wrapper_1.runExecWrapper)({ logsRoot, jobId: job.id, nonce, argv: job.argv, cwd: job.cwd, repoRoot }).catch(() => { });
+};
+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 });
+}
+async function until(fn, ms = 15000) {
+    const t0 = Date.now();
+    while (!fn()) {
+        if (Date.now() - t0 > ms)
+            throw new Error('timeout');
+        await new Promise((r) => setTimeout(r, 50));
+    }
+}
+describe('integracion supervisor + jobs', () => {
+    let repo;
+    let fpNow;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-int-'));
+        git(repo, 'init', '-q', '-b', 'main');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'node -e "process.exit(0)"' } }));
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c');
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), '{}');
+        (0, init_1.initWatch)(repo, 'main'); // gitignorea .awm ANTES del primer fingerprint
+        fpNow = (argv, paths, cwd) => {
+            try {
+                return (0, fingerprint_1.computeFingerprint)(repo, argv, paths, cwd).fingerprint;
+            }
+            catch {
+                return null;
+            }
+        };
+    });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    async function drainJobs() {
+        await until(() => {
+            (0, runner_1.runnerTick)(repo, 'main', fakeSpawner, { reconcileGraceMs: 10000 });
+            const s = (0, store_1.readJournal)(repo, 'main').state;
+            return Object.values(s.jobs).every((j) => !['received', 'spawn-intent', 'claimed', 'running'].includes(j.executionState));
+        });
+    }
+    test('e2e in-process: request => supervisor ejecuta => resultado en journal, dedup por key (RNF-T.7, R4.4)', async () => {
+        (0, request_1.requestJob)(repo, 'main', 'g1', ['node', '-e', 'process.exit(0)'], [], '.');
+        (0, request_1.requestJob)(repo, 'main', 'g1', ['node', '-e', 'process.exit(0)'], [], '.'); // misma key
+        (0, apply_1.consumePendingRequests)(repo, 'main', 'g1');
+        await drainJobs();
+        const s = (0, store_1.readJournal)(repo, 'main').state;
+        const jobs = Object.values(s.jobs);
+        expect(jobs).toHaveLength(1); // get-or-create: un solo job (RNF-T.7)
+        expect(jobs[0].executionState).toBe('exited');
+        expect(jobs[0].verdict).toBe('pass');
+    });
+    test('job fallido ENLAZADO al plan bloquea el gate por adverse-verdict (R1.4c)', async () => {
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [{ id: 'v1', kind: 'test' }, { id: 'v-sensors', kind: 'sensors' }], reviewObligations: [] } });
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e2',
+            payload: { entity: 'cycle-plan', items: [{ id: 'cv1', kind: 'qa' }] } });
+        // job largo que FALLA, enlazado a v1 (bloqueador 5: el test v1 no enlazaba)
+        (0, request_1.requestJob)(repo, 'main', 'g1', ['node', '-e', 'setTimeout(()=>process.exit(1), 1200)'], [], '.', { satisfies: 'v1' });
+        (0, apply_1.consumePendingRequests)(repo, 'main', 'g1');
+        await drainJobs(); // sin timeout terminal: espera lo que dure (R3.5)
+        const s = (0, store_1.readJournal)(repo, 'main').state;
+        const g = (0, gate_1.computeGate)(s, false, fpNow);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'adverse-verdict' && /v1/.test(r.detail))).toBe(true);
+        expect(g.reasons.some((r) => r.category === 'live-job')).toBe(false); // pero SI termino
+    });
+    test('evidencia pass con arbol cambiado despues => stale-fingerprint, historica (RF-2.8)', async () => {
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
+            payload: { entity: 'cycle-plan', items: [
+                    { id: 'cv-qa', kind: 'qa' }, { id: 'cv-interlock', kind: 'interlock' },
+                    { id: 'cv-test', kind: 'test' }, { id: 'cv-sensors', kind: 'sensors' },
+                ] } });
+        for (const item of ['cv-qa', 'cv-interlock', 'cv-test', 'cv-sensors']) {
+            (0, request_1.requestJob)(repo, 'main', 'g1', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: item });
+        }
+        (0, apply_1.consumePendingRequests)(repo, 'main', 'g1');
+        await drainJobs();
+        expect((0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'main').state, false, fpNow).pass).toBe(true);
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'CAMBIO'); // el arbol cambio tras la evidencia
+        const g = (0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'main').state, false, fpNow);
+        expect(g.pass).toBe(false);
+        expect(g.reasons.some((r) => r.category === 'stale-fingerprint')).toBe(true);
+    });
+    test('custodia: doble senial sin safe => custody-blocked, jamas kill (R4.2b)', () => {
+        const d = (0, generations_1.decideStall)({ heartbeatAgeMs: 999999, activityFrozenMs: 999999, safeToReplace: 'indeterminate' }, { heartbeatTimeoutMs: 1, activityWindowMs: 1 });
+        expect(d).toBe('custody-blocked');
+    });
+    test('interrupcion entre spawn-intent y claim: la matriz decide por claim, no re-spawnea a ciegas (R1.8)', () => {
+        (0, request_1.requestJob)(repo, 'main', 'g1', ['node', '-e', 'process.exit(0)'], [], '.');
+        (0, apply_1.consumePendingRequests)(repo, 'main', 'g1');
+        const s = (0, store_1.readJournal)(repo, 'main').state;
+        const jid = Object.keys(s.jobs)[0];
+        s.jobs[jid].executionState = 'spawn-intent'; // crash simulado: intent persistido, spawn jamas ocurrio
+        s.jobs[jid].spawnNonce = 'nunca-uso';
+        const out = (0, reconcile_1.reconcileJobs)(s, (0, paths_1.logsDir)(repo, 'main'));
+        expect(out.decisions[0].action).toBe('retry-same-intent'); // mismo nonce: el claim wx impide duplicar
+    });
+});

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

@@ -0,0 +1,60 @@
+"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 lock_1 = require("../../../src/commands/watch/lock");
+const paths_1 = require("../../../src/core/journal/paths");
+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 });
+}
+describe('supervisor lock + branch invariant', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-lock-')); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('adquisicion exclusiva: la segunda falla con supervisor vivo (R4.1)', () => {
+        const l1 = (0, lock_1.acquireLock)(repo);
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(true);
+        expect(() => (0, lock_1.acquireLock)(repo)).toThrow(/supervisor activo/);
+        (0, lock_1.releaseLock)(repo, l1);
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(false);
+    });
+    test('lock con identidad muerta PROBADA se reclama con reintento unico (R4.1)', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname((0, paths_1.supervisorLockPath)(repo)), { recursive: true });
+        fs_1.default.writeFileSync((0, paths_1.supervisorLockPath)(repo), JSON.stringify({
+            pid: 999999, startTime: 'gone', spawnNonce: 'x', argvDigest: 'y', processGroup: 999999, psArgsDigest: 'z',
+        }));
+        const l = (0, lock_1.acquireLock)(repo);
+        expect(l.ref.pid).toBe(process.pid);
+        (0, lock_1.releaseLock)(repo, l);
+    });
+    test('lock ilegible o con shape invalido => LockBlockedError, JAMAS se reclama (R4.1)', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname((0, paths_1.supervisorLockPath)(repo)), { recursive: true });
+        fs_1.default.writeFileSync((0, paths_1.supervisorLockPath)(repo), '{json roto');
+        expect(() => (0, lock_1.acquireLock)(repo)).toThrow(lock_1.LockBlockedError);
+        fs_1.default.writeFileSync((0, paths_1.supervisorLockPath)(repo), JSON.stringify({ pid: 1 })); // shape parcial
+        expect(() => (0, lock_1.acquireLock)(repo)).toThrow(lock_1.LockBlockedError);
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(true); // sigue ahi: nadie lo piso
+    });
+    test('branch invariant: discrepancia rama-journal => BLOCKED (R1.1)', () => {
+        git(repo, 'init', '-q', '-b', 'main');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c');
+        expect(() => (0, lock_1.verifyBranchInvariant)(repo, 'main')).not.toThrow();
+        git(repo, 'checkout', '-qb', 'otra');
+        expect(() => (0, lock_1.verifyBranchInvariant)(repo, 'main')).toThrow(/BLOCKED/);
+    });
+    test('branch invariant: HEAD detached => BLOCKED, jamas matchea (R1.1)', () => {
+        git(repo, 'init', '-q', '-b', 'main');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c');
+        git(repo, 'checkout', '-q', '--detach', 'HEAD');
+        expect(() => (0, lock_1.verifyBranchInvariant)(repo, 'main')).toThrow(/BLOCKED/);
+    });
+});

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

@@ -0,0 +1,239 @@
+"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 runner_1 = require("../../../src/commands/watch/runner");
+const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const process_1 = require("../../../src/core/journal/process");
+const fakeSpawner = (job, nonce, logsRoot, repoRoot) => {
+    // Mismo contrato que el spawner real: dispara el wrapper y NO espera.
+    void (0, exec_wrapper_1.runExecWrapper)({ logsRoot, jobId: job.id, nonce, argv: job.argv, cwd: job.cwd, repoRoot }).catch(() => { });
+};
+async function until(fn, ms = 8000) {
+    const t0 = Date.now();
+    while (!fn()) {
+        if (Date.now() - t0 > ms)
+            throw new Error('timeout esperando condicion');
+        await new Promise((r) => setTimeout(r, 50));
+    }
+}
+function seedJob(repo, partial) {
+    const s = (0, store_1.readJournal)(repo, 'rama').state;
+    const j = {
+        id: 'j1', fingerprint: 'fp', commandDigest: 'cd', argv: ['node', '-e', 'process.exit(0)'], cwd: '.',
+        paths: [], expandedPaths: [], executionState: 'received', observationState: 'progressing',
+        phaseTimestamps: { received: new Date().toISOString() }, ...partial,
+    };
+    s.jobs[j.id] = j;
+    (0, store_1.writeJournal)(repo, 'rama', s);
+    return j.id;
+}
+describe('runner concurrente', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-run-')); (0, store_1.initJournal)(repo, 'rama'); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('spawnPendingWrappers persiste spawn-intent+nonce ANTES del spawn y NO bloquea (R1.8, R4.4)', async () => {
+        seedJob(repo, { argv: ['node', '-e', 'setTimeout(()=>process.exit(0), 800)'] });
+        const spawned = (0, runner_1.spawnPendingWrappers)(repo, 'rama', fakeSpawner);
+        expect(spawned).toBe(1);
+        // Retorno INMEDIATO: el job aun no esta exited — el supervisor no espero
+        const mid = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+        expect(['spawn-intent', 'claimed', 'running']).toContain(mid.executionState);
+        expect(typeof mid.spawnNonce).toBe('string'); // intent durable pre-spawn
+        await until(() => {
+            (0, runner_1.collectAndReconcile)(repo, 'rama');
+            return (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].executionState === 'exited';
+        });
+        const done = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+        expect(done.verdict).toBe('pass');
+        expect(done.processRef.pid).toBeGreaterThan(0); // identidad REAL adoptada del sidecar
+        expect(done.wrapperRef.pid).toBeGreaterThan(0);
+    });
+    test('job largo pasa por running con identidad real; jamas se mata por duracion (R3.5)', async () => {
+        seedJob(repo, { argv: ['node', '-e', 'setTimeout(()=>process.exit(0), 1500)'] });
+        (0, runner_1.spawnPendingWrappers)(repo, 'rama', fakeSpawner);
+        await until(() => {
+            (0, runner_1.collectAndReconcile)(repo, 'rama');
+            return (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].executionState === 'running';
+        });
+        const running = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+        expect(running.processRef.psArgsDigest).toMatch(/^[0-9a-f]{16}$/);
+        await until(() => {
+            (0, runner_1.collectAndReconcile)(repo, 'rama');
+            return (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].executionState === 'exited';
+        });
+    });
+    test('spawn-intent sin claim fuera de gracia => re-spawn del MISMO intent y nonce (R3.3/R1.8)', () => {
+        seedJob(repo, {
+            executionState: 'spawn-intent', spawnNonce: 'nunca-claimeo',
+            phaseTimestamps: { 'spawn-intent': new Date(Date.now() - 60000).toISOString() },
+        });
+        const calls = [];
+        const out = (0, runner_1.runnerTick)(repo, 'rama', (job, nonce) => { calls.push({ id: job.id, nonce }); }, { reconcileGraceMs: 1000 });
+        expect(out.decisions.find((d) => d.action === 'retry-same-intent')).toBeDefined();
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(Object.keys(s.jobs)).toEqual(['j1']);
+        expect(s.jobs['j1'].executionState).toBe('spawn-intent');
+        expect(s.jobs['j1'].spawnNonce).toBe('nunca-claimeo');
+        expect(calls).toEqual([{ id: 'j1', nonce: 'nunca-claimeo' }]);
+    });
+    test('claim sin resultado con procesos muertos => orphaned, jamas relanzar (R1.8)', () => {
+        const dead = { pid: 999999, startTime: 'gone', spawnNonce: 'nZ', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        seedJob(repo, {
+            executionState: 'running', spawnNonce: 'nZ', processRef: dead, wrapperRef: { ...dead, pid: 999998 },
+            phaseTimestamps: { running: new Date(Date.now() - 60000).toISOString() },
+        });
+        fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nZ'), '{}');
+        const out = (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 1000 });
+        expect(out.decisions.find((d) => d.action === 'orphaned-authorization-required')).toBeDefined();
+        expect((0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].executionState).toBe('orphaned');
+    });
+    test('identity sidecar a medio escribir (JSON invalido) => no avanza esta vuelta, no crashea; tick siguiente con identidad valida si avanza', () => {
+        seedJob(repo, {
+            executionState: 'claimed', spawnNonce: 'nI',
+            phaseTimestamps: { claimed: new Date().toISOString() },
+        });
+        fs_1.default.writeFileSync((0, exec_wrapper_1.identityPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nI'), '{ esto no es json valido');
+        expect(() => (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000 })).not.toThrow();
+        const mid = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+        expect(mid.executionState).toBe('claimed'); // sin avance: el sidecar aun no es legible
+        expect(mid.processRef).toBeUndefined();
+        const validIdentity = {
+            jobId: 'j1', nonce: 'nI',
+            wrapper: { pid: 111, startTime: 'x', spawnNonce: 'nI', argvDigest: 'd', processGroup: 111, psArgsDigest: 'e' },
+            command: { pid: 112, startTime: 'x', spawnNonce: 'nI', argvDigest: (0, process_1.argvDigest)(['node', '-e', 'process.exit(0)']), processGroup: 111, psArgsDigest: 'e' },
+        };
+        fs_1.default.writeFileSync((0, exec_wrapper_1.identityPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nI'), JSON.stringify(validIdentity));
+        (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000 });
+        const done = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+        expect(done.executionState).toBe('running');
+        expect(done.processRef.pid).toBe(112);
+    });
+    test('identity sidecar con JSON valido pero forma invalida (ProcessRef incompleto) => no avanza, no crashea (R1.8)', () => {
+        seedJob(repo, {
+            executionState: 'claimed', spawnNonce: 'nJ',
+            phaseTimestamps: { claimed: new Date().toISOString() },
+        });
+        fs_1.default.writeFileSync((0, exec_wrapper_1.identityPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nJ'), JSON.stringify({ jobId: 'j1', nonce: 'nJ', wrapper: {}, command: {} }));
+        expect(() => (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000 })).not.toThrow();
+        const mid = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+        expect(mid.executionState).toBe('claimed');
+        expect(mid.processRef).toBeUndefined();
+    });
+    test('claim sidecar a medio escribir (contenido no-JSON) igual dispara claimed — el contenido nunca se parsea (R1.8)', () => {
+        seedJob(repo, {
+            executionState: 'spawn-intent', spawnNonce: 'nK',
+            phaseTimestamps: { 'spawn-intent': new Date().toISOString() },
+        });
+        fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nK'), '{"jobId":"j1truncado-sin-cerrar');
+        expect(() => (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000 })).not.toThrow();
+        expect((0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].executionState).toBe('claimed');
+    });
+    test('resultado parcial con solo exitCode => el scan no lo adopta; fuera de gracia cae a orphaned, jamas fabrica pass (R1.6)', () => {
+        const dead = { pid: 999999, startTime: 'gone', spawnNonce: 'nL', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        seedJob(repo, {
+            executionState: 'running', spawnNonce: 'nL', processRef: dead,
+            phaseTimestamps: { running: new Date(Date.now() - 60000).toISOString() },
+        });
+        fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nL'), '{}');
+        fs_1.default.writeFileSync((0, exec_wrapper_1.resultPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nL'), JSON.stringify({ exitCode: 0 }));
+        const out = (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 1000 });
+        expect(out.decisions.find((d) => d.action === 'orphaned-authorization-required')).toBeDefined();
+        const done = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+        expect(done.executionState).toBe('orphaned');
+        expect(done.verdict).toBeUndefined(); // jamas fabricado de un sidecar sin forma
+    });
+    test('resultado completo sin claim no se adopta como evidencia', () => {
+        seedJob(repo, {
+            executionState: 'spawn-intent', spawnNonce: 'nNoClaim',
+            phaseTimestamps: { 'spawn-intent': new Date(Date.now() - 60000).toISOString() },
+        });
+        fs_1.default.writeFileSync((0, exec_wrapper_1.resultPath)((0, paths_1.logsDir)(repo, 'rama'), 'j1', 'nNoClaim'), JSON.stringify({
+            exitCode: 0, endedAt: new Date().toISOString(), resultPath: 'forged',
+        }));
+        const out = (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 1000 });
+        expect(out.decisions).toContainEqual({ jobId: 'j1', action: 'retry-same-intent' });
+        const job = (0, store_1.readJournal)(repo, 'rama').state.jobs.j1;
+        expect(job.executionState).toBe('spawn-intent');
+        expect(job.verdict).toBeUndefined();
+    });
+    test('runnerTick combina recoleccion + spawn en un tick sin esperar (R4.4)', async () => {
+        seedJob(repo, {});
+        const out = (0, runner_1.runnerTick)(repo, 'rama', fakeSpawner, { reconcileGraceMs: 10000 });
+        expect(out.spawned).toBe(1);
+        await until(() => (0, runner_1.runnerTick)(repo, 'rama', fakeSpawner, { reconcileGraceMs: 10000 }).advanced > 0
+            || (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].executionState === 'exited');
+    });
+    describe('observationState: suspected-stall por staleness del log, puramente observacional (R3.5)', () => {
+        function seedRunning(nonce, runningAt) {
+            const dead = { pid: 999999, startTime: 'gone', spawnNonce: nonce, argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+            seedJob(repo, {
+                executionState: 'running', spawnNonce: nonce, processRef: dead, wrapperRef: { ...dead, pid: 999998 },
+                phaseTimestamps: { running: runningAt }, lastProgressAt: runningAt,
+            });
+        }
+        test('log que sigue creciendo (mtime avanza cada tick) queda progressing aun pasado el umbral', async () => {
+            const oldIso = new Date(Date.now() - 60000).toISOString();
+            seedRunning('nStall1', oldIso);
+            const logs = (0, paths_1.logsDir)(repo, 'rama');
+            fs_1.default.mkdirSync(logs, { recursive: true });
+            const file = (0, exec_wrapper_1.logPath)(logs, 'j1', 'nStall1');
+            fs_1.default.writeFileSync(file, 'salida inicial\n');
+            // umbral MUY corto (10ms): si el job estuviera realmente stalled, cualquiera
+            // de estos 3 ticks lo marcaria suspected-stall — pero el log sigue creciendo.
+            for (let i = 0; i < 3; i++) {
+                await new Promise((res) => setTimeout(res, 20)); // > stallObservationMs entre escrituras
+                fs_1.default.appendFileSync(file, `linea ${i}\n`);
+                (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000, stallObservationMs: 10 });
+                expect((0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].observationState).toBe('progressing');
+            }
+        });
+        // El log se escribe con un mtime EXPLICITAMENTE anterior a `lastProgressAt`
+        // (utimesSync, no timing de reloj real) — determinista, sin flakiness por
+        // resolucion de mtime del filesystem. Misma semantica que el runner real:
+        // el log no avanzo desde la ultima marca de progreso conocida.
+        function seedRunningWithStaleLog(nonce, content) {
+            const logs = (0, paths_1.logsDir)(repo, 'rama');
+            fs_1.default.mkdirSync(logs, { recursive: true });
+            const file = (0, exec_wrapper_1.logPath)(logs, 'j1', nonce);
+            fs_1.default.writeFileSync(file, content);
+            const past = new Date(Date.now() - 5000);
+            fs_1.default.utimesSync(file, past, past);
+            seedRunning(nonce, new Date(Date.now() - 1000).toISOString());
+        }
+        test('log sin crecer por mas del umbral => suspected-stall, executionState intacto (jamas mata nada)', () => {
+            seedRunningWithStaleLog('nStall2', 'salida unica, nunca mas crece\n');
+            (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000, stallObservationMs: 10 });
+            const j = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+            expect(j.observationState).toBe('suspected-stall');
+            expect(j.executionState).toBe('running'); // observacional puro: nunca produce transicion terminal (R3.5)
+        });
+        test('un job stalled vuelve a progressing si el log retoma crecimiento', () => {
+            seedRunningWithStaleLog('nStall3', 'salida vieja\n');
+            (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000, stallObservationMs: 10 });
+            expect((0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].observationState).toBe('suspected-stall');
+            const logs = (0, paths_1.logsDir)(repo, 'rama');
+            fs_1.default.appendFileSync((0, exec_wrapper_1.logPath)(logs, 'j1', 'nStall3'), 'output nuevo: el job seguia vivo\n');
+            (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000, stallObservationMs: 10 });
+            expect((0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].observationState).toBe('progressing');
+        });
+        test('un job stalled que termina llega a exited via el sidecar de resultado normal, sin intervencion de staleness', () => {
+            seedRunningWithStaleLog('nStall4', 'salida vieja\n');
+            (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000, stallObservationMs: 10 });
+            expect((0, store_1.readJournal)(repo, 'rama').state.jobs['j1'].observationState).toBe('suspected-stall');
+            const logs = (0, paths_1.logsDir)(repo, 'rama');
+            fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)(logs, 'j1', 'nStall4'), '{}');
+            fs_1.default.writeFileSync((0, exec_wrapper_1.resultPath)(logs, 'j1', 'nStall4'), JSON.stringify({ exitCode: 0, endedAt: new Date().toISOString(), resultPath: 'x' }));
+            (0, runner_1.collectAndReconcile)(repo, 'rama', { reconcileGraceMs: 60000, stallObservationMs: 10 });
+            const j = (0, store_1.readJournal)(repo, 'rama').state.jobs['j1'];
+            expect(j.executionState).toBe('exited');
+            expect(j.verdict).toBe('pass');
+        });
+    });
+});