agentic-workflow-manager 3.4.0 → 3.5.0

package/dist/tests/commands/watch/supervisor-loop.test.js

@@ -0,0 +1,203 @@
+"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 supervisor_1 = require("../../../src/commands/watch/supervisor");
+const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+const generations_1 = require("../../../src/commands/watch/generations");
+const init_1 = require("../../../src/commands/watch/init");
+const request_1 = require("../../../src/commands/job/request");
+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 process_1 = require("../../../src/core/journal/process");
+const fingerprint_1 = require("../../../src/core/journal/fingerprint");
+jest.setTimeout(60000);
+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 });
+}
+function setupRepo() {
+    const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-loop-'));
+    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');
+    fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'node -e "process.exit(0)"' } }));
+    fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), '{}');
+    return repo;
+}
+function emitVerdict(repo, token, obligationId, verdictId) {
+    const argv = ['awm-review', obligationId];
+    const fp = (0, fingerprint_1.computeFingerprint)(repo, argv, [], '.').fingerprint;
+    (0, requests_1.emitRequest)(repo, 'main', { kind: 'verdict', generationToken: token, idempotencyKey: verdictId,
+        payload: { verdictId, obligationId, result: 'pass', detail: 'ok', fingerprint: fp, argv, paths: [], cwd: '.' } });
+}
+async function until(fn, ms = 30000) {
+    const t0 = Date.now();
+    while (!fn()) {
+        if (Date.now() - t0 > ms)
+            throw new Error('timeout');
+        await new Promise((r) => setTimeout(r, 50));
+    }
+}
+describe('supervisor loop', () => {
+    let repo;
+    let stubBin;
+    let oldPath;
+    beforeEach(() => {
+        repo = setupRepo();
+        stubBin = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-stub-'));
+        fs_1.default.writeFileSync(path_1.default.join(stubBin, 'codex'), '#!/bin/sh\nwhile true; do sleep 1; done\n', { mode: 0o755 });
+        oldPath = process.env.PATH;
+        process.env.PATH = `${stubBin}:${process.env.PATH}`;
+    });
+    afterEach(() => {
+        process.env.PATH = oldPath;
+        fs_1.default.rmSync(repo, { recursive: true, force: true });
+        fs_1.default.rmSync(stubBin, { recursive: true, force: true });
+    });
+    test('ticks drenan y declaran COMPLETE solo con gate verde + cero vivos (R4.5)', async () => {
+        (0, init_1.initWatch)(repo, 'main'); // sin package.json => requiredVerifiers []
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 50, reconcileGraceMs: 10000 };
+        const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner);
+        // el controlador (aqui: el test) registra plan de ciclo + task + jobs enlazados
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e1',
+            payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [{ id: 'v1', kind: 'test' }, { id: 'v-sensors', kind: 'sensors' }], reviewObligations: [{ id: 'o-spec', kind: 'spec' }, { id: 'o-quality', kind: 'quality' }] } });
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e2',
+            payload: { entity: 'cycle-plan', items: [{ id: 'cv1', kind: 'qa' }, { id: 'cv-interlock', kind: 'interlock' }] } });
+        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'setTimeout(()=>process.exit(0), 400)'], [], '.', { satisfies: 'v1' });
+        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'v-sensors' });
+        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv1' });
+        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv-interlock' });
+        emitVerdict(repo, 'g0', 'o-spec', 'verd-spec');
+        emitVerdict(repo, 'g0', 'o-quality', 'verd-quality');
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e3',
+            payload: { entity: 'task-status', taskId: 'T1', status: 'done' } });
+        let sawContinueWithLiveJob = false;
+        let outcome = 'continue';
+        for (let i = 0; i < 400 && outcome !== 'complete'; i++) {
+            outcome = await sup.tick();
+            const s = (0, store_1.readJournal)(repo, 'main').state;
+            const live = Object.values(s.jobs).some((j) => ['received', 'spawn-intent', 'claimed', 'running'].includes(j.executionState));
+            if (outcome === 'continue' && live)
+                sawContinueWithLiveJob = true; // drenaje ANTES de COMPLETE
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        expect(outcome).toBe('complete');
+        expect(sawContinueWithLiveJob).toBe(true);
+        const final = (0, store_1.readJournal)(repo, 'main').state;
+        expect(final.cycle.status).toBe('COMPLETE');
+        expect(typeof final.cycle.completedAt).toBe('string');
+        expect(Object.values(final.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass')).toBe(true);
+    });
+    test('tick verifica branch antes del launch y un ciclo COMPLETE no lanza otro controller', async () => {
+        (0, init_1.initWatch)(repo, 'main');
+        let calls = 0;
+        const spy = () => { calls++; };
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10 };
+        const s = (0, store_1.readJournal)(repo, 'main').state;
+        s.cycle.status = 'COMPLETE';
+        (0, store_1.writeJournal)(repo, 'main', s);
+        expect(await new supervisor_1.Supervisor(repo, 'main', cfg, spy).tick()).toBe('complete');
+        expect(calls).toBe(0);
+        const reset = (0, store_1.readJournal)(repo, 'main').state;
+        reset.cycle.status = 'IN_PROGRESS';
+        (0, store_1.writeJournal)(repo, 'main', reset);
+        git(repo, 'checkout', '-qb', 'otra');
+        await expect(new supervisor_1.Supervisor(repo, 'main', cfg, spy).tick()).rejects.toThrow(/rama|branch/i);
+        expect(calls).toBe(0);
+    });
+    test('fallo de launch queda durable y entra en backoff sin tumbar el supervisor (R4.3)', async () => {
+        (0, init_1.initWatch)(repo, 'main');
+        (0, generations_1.beginGeneration)(repo, 'main');
+        let calls = 0;
+        const failing = () => { calls++; throw new Error('provider unavailable'); };
+        const sup = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10 }, failing);
+        await expect(sup.tick()).resolves.toBe('continue');
+        expect(calls).toBe(1);
+        const intent = (0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'main').state);
+        expect(intent.controllerJobId).toBeDefined();
+        expect(intent.spawnNonce).toBeDefined();
+        await expect(sup.tick()).resolves.toBe('continue');
+        expect(calls).toBe(1); // primer backoff es 60 s: no hace hot-loop
+    });
+    test('custodia: doble senial + indeterminate => tick custody, lock retenido, proceso intacto (R4.2b/R4.5)', async () => {
+        (0, store_1.initJournal)(repo, 'main');
+        (0, generations_1.beginGeneration)(repo, 'main');
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 20000)'], process.cwd(), 'nCtl');
+        let s = (0, store_1.readJournal)(repo, 'main').state;
+        (0, generations_1.activeGeneration)(s).processRef = ref;
+        s.controllerHeartbeatAt = new Date(Date.now() - 3600000).toISOString(); // heartbeat vencido hace 1h
+        (0, store_1.writeJournal)(repo, 'main', s);
+        fs_1.default.mkdirSync(path_1.default.dirname((0, paths_1.supervisorLockPath)(repo)), { recursive: true });
+        fs_1.default.writeFileSync((0, paths_1.supervisorLockPath)(repo), 'lock-del-loop'); // el loop lo tendria: NO debe borrarse
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', heartbeatTimeoutMs: 1, activityWindowMs: 50, tickMs: 20 };
+        const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner);
+        await sup.tick(); // primer tick: arranca el tracking de actividad
+        await new Promise((r) => setTimeout(r, 150)); // actividad congelada > ventana
+        const out = await sup.tick();
+        expect(out).toBe('custody');
+        const after = (0, store_1.readJournal)(repo, 'main').state;
+        expect(after.cycle.status).toBe('BLOCKED');
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(true); // custodia NO libera el lock
+        expect(child.killed).toBe(false); // y NO mato al controlador
+        child.kill('SIGKILL');
+    });
+    test('runSupervisorLoop: bootstrap gen-1 con stub codex, COMPLETE => libera lock y termina su generacion (R4.1/R4.5/R2.4)', async () => {
+        (0, init_1.initWatch)(repo, 'main');
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 50, termGraceMs: 300, killGraceMs: 300 };
+        const loop = (0, supervisor_1.runSupervisorLoop)(repo, 'main', cfg, fakeSpawner);
+        await until(() => {
+            const r = (0, store_1.readJournal)(repo, 'main');
+            return r.state !== null && (0, generations_1.activeGeneration)(r.state) !== undefined && fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo));
+        });
+        const token = (0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'main').state).token;
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: token, idempotencyKey: 'e1',
+            payload: { entity: 'cycle-plan', items: [{ id: 'cv1', kind: 'qa' }, { id: 'cv2', kind: 'interlock' }, { id: 'cv3', kind: 'test' }, { id: 'cv4', kind: 'sensors' }] } });
+        (0, request_1.requestJob)(repo, 'main', token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv1' });
+        (0, request_1.requestJob)(repo, 'main', token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv2' });
+        (0, request_1.requestJob)(repo, 'main', token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv3' });
+        (0, request_1.requestJob)(repo, 'main', token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv4' });
+        await loop; // auto-exit tras COMPLETE
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(false); // lock liberado
+        const final = (0, store_1.readJournal)(repo, 'main').state;
+        expect(final.cycle.status).toBe('COMPLETE');
+        const gen = final.generations[0];
+        // generacion propia terminada: cero procesos codex huerfanos (R2.4)
+        const { refIsAlive } = require('../../../src/core/journal/process');
+        expect(gen.processRef === undefined || !refIsAlive(gen.processRef)).toBe(true);
+    });
+    test('reinicio tras crash entre beginGeneration y spawn recupera la misma generacion sin quedar wedged', async () => {
+        (0, init_1.initWatch)(repo, 'main');
+        const begun = (0, generations_1.beginGeneration)(repo, 'main'); // crash simulado: intent durable, sin ProcessRef
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 25, reconcileGraceMs: 300,
+            termGraceMs: 300, killGraceMs: 300 };
+        const loop = (0, supervisor_1.runSupervisorLoop)(repo, 'main', cfg, fakeSpawner);
+        let recovered = false;
+        try {
+            await until(() => {
+                const active = (0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'main').state);
+                recovered = active?.token === begun.token && active.processRef !== undefined;
+                return recovered;
+            }, 1500);
+        }
+        catch { /* la asercion de abajo conserva un fallo limpio y permite apagar el loop */ }
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: begun.token, idempotencyKey: 'recover-plan',
+            payload: { entity: 'cycle-plan', items: [{ id: 'r-qa', kind: 'qa' }, { id: 'r-interlock', kind: 'interlock' }, { id: 'r-test', kind: 'test' }, { id: 'r-sensors', kind: 'sensors' }] } });
+        for (const item of ['r-qa', 'r-interlock', 'r-test', 'r-sensors']) {
+            (0, request_1.requestJob)(repo, 'main', begun.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: item });
+        }
+        await loop;
+        expect(recovered).toBe(true);
+        expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(1);
+    });
+});

package/dist/tests/commands/watch/watch-init.test.js

@@ -0,0 +1,43 @@
+"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 init_1 = require("../../../src/commands/watch/init");
+const store_1 = require("../../../src/core/journal/store");
+describe('watch --init: plan-vs-repo mecanico', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-')); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('package.json con script test => verificador test requerido (R1.4b)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'jest' } }));
+        expect((0, init_1.detectRequiredVerifiers)(repo)).toEqual(['test']);
+    });
+    test('sensors.json => verificador sensors requerido; ambos => ambos (R1.4b)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'jest' } }));
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), '{}');
+        expect((0, init_1.detectRequiredVerifiers)(repo)).toEqual(['test', 'sensors']);
+    });
+    test('descubre suite y sensors en paquetes anidados del repositorio', () => {
+        const cli = path_1.default.join(repo, 'cli');
+        fs_1.default.mkdirSync(path_1.default.join(cli, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(cli, 'package.json'), JSON.stringify({ scripts: { test: 'jest' } }));
+        fs_1.default.writeFileSync(path_1.default.join(cli, '.awm', 'sensors.json'), '{}');
+        expect((0, init_1.detectRequiredVerifiers)(repo)).toEqual(['test', 'sensors']);
+    });
+    test('repo sin verificadores => lista vacia (el gate degrada por empty-cycle-plan igualmente, R3.6)', () => {
+        expect((0, init_1.detectRequiredVerifiers)(repo)).toEqual([]);
+    });
+    test('initWatch persiste requiredVerifiers y gitignorea el journal (R1.1/R1.4b)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'jest' } }));
+        const out = (0, init_1.initWatch)(repo, 'rama');
+        expect(out.requiredVerifiers).toEqual(['test']);
+        expect((0, store_1.readJournal)(repo, 'rama').state.requiredVerifiers).toEqual(['test']);
+        expect(fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8')).toContain('.awm/');
+        expect(() => (0, init_1.initWatch)(repo, 'rama')).not.toThrow(); // idempotente
+    });
+});

package/dist/tests/core/atomic-file-durable.test.js

@@ -0,0 +1,42 @@
+"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 atomic_file_1 = require("../../src/core/atomic-file");
+describe('writeFileAtomicDurable', () => {
+    let dir;
+    beforeEach(() => { dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-durable-')); });
+    afterEach(() => { jest.restoreAllMocks(); fs_1.default.rmSync(dir, { recursive: true, force: true }); });
+    test('escribe contenido y respeta mode 0600 (R1.2)', () => {
+        const f = path_1.default.join(dir, 'state.json');
+        (0, atomic_file_1.writeFileAtomicDurable)(f, '{"a":1}', 0o600);
+        expect(fs_1.default.readFileSync(f, 'utf8')).toBe('{"a":1}');
+        expect(fs_1.default.statSync(f).mode & 0o777).toBe(0o600);
+    });
+    test('sobrevive a reemplazos consecutivos sin residuo tmp (R1.2)', () => {
+        const f = path_1.default.join(dir, 'state.json');
+        (0, atomic_file_1.writeFileAtomicDurable)(f, 'v1', 0o600);
+        (0, atomic_file_1.writeFileAtomicDurable)(f, 'v2', 0o600);
+        expect(fs_1.default.readFileSync(f, 'utf8')).toBe('v2');
+        expect(fs_1.default.readdirSync(dir).filter((n) => n.includes('.tmp'))).toEqual([]);
+    });
+    test('fallo del fsync de directorio LANZA — sin fallback silencioso (R1.2)', () => {
+        const f = path_1.default.join(dir, 'state.json');
+        const realOpen = fs_1.default.openSync;
+        // writeFileAtomic abre el tmp con 'wx'; el fsync de directorio abre con 'r':
+        // simulamos que el open del directorio falla (EIO/EPERM segun filesystem).
+        jest.spyOn(fs_1.default, 'openSync').mockImplementation(((p, flags, mode) => {
+            if (flags === 'r')
+                throw new Error('EIO simulado');
+            return realOpen(p, flags, mode);
+        }));
+        expect(() => (0, atomic_file_1.writeFileAtomicDurable)(f, '{"a":1}', 0o600)).toThrow(/fsync de directorio/);
+    });
+    test('fsyncDirSync exitoso no lanza sobre un directorio real (R1.2)', () => {
+        expect(() => (0, atomic_file_1.fsyncDirSync)(dir)).not.toThrow();
+    });
+});

package/dist/tests/core/journal/adapter.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = require("../../../src/core/journal/adapter");
+const process_1 = require("../../../src/core/journal/process");
+describe('ControllerAdapter', () => {
+    test('adapterFor resuelve codex y claude-code; provider desconocido lanza (R4.8)', () => {
+        expect((0, adapter_1.adapterFor)('codex').provider).toBe('codex');
+        expect((0, adapter_1.adapterFor)('claude-code').provider).toBe('claude-code');
+        expect(() => (0, adapter_1.adapterFor)('otro')).toThrow(/provider/);
+    });
+    test('safeToReplace: muerto probado => safe; vivo => indeterminate, JAMAS safe sin evidencia (R4.2b)', () => {
+        const a = (0, adapter_1.adapterFor)('codex');
+        const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'n', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        expect(a.safeToReplace(deadRef)).toBe('safe'); // identidad no matchea a nadie vivo => muerte probada
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 3000)'], process.cwd(), 'nA');
+        expect(a.safeToReplace(ref)).toBe('indeterminate'); // vivo: codex no observa llamadas en vuelo => custodia
+        child.kill('SIGKILL');
+    });
+    test('launchArgv construye el comando de reanudacion journal-first (R4.8)', () => {
+        const argv = (0, adapter_1.adapterFor)('codex').launchArgv('retoma desde next_action');
+        expect(argv[0]).toBe('codex');
+        expect(argv).toContain('exec');
+        expect(argv[argv.length - 1]).toContain('next_action');
+        const cl = (0, adapter_1.adapterFor)('claude-code').launchArgv('retoma desde next_action');
+        expect(cl[0]).toBe('claude');
+    });
+});

package/dist/tests/core/journal/fingerprint.test.js

@@ -0,0 +1,164 @@
+"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 fingerprint_1 = require("../../../src/core/journal/fingerprint");
+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('computeFingerprint', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-fp-'));
+        git(repo, 'init', '-q');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'a.txt'), 'uno');
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c1');
+    });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('mismo comando + mismo arbol + mismo cwd => mismo fingerprint (R3.4)', () => {
+        const a = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.');
+        const b = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.');
+        expect(a.fingerprint).toBe(b.fingerprint);
+        expect(a.commandDigest).toBe(b.commandDigest);
+    });
+    test('cambio en tracked, untracked o argv cambia el fingerprint (R3.4)', () => {
+        const base = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'a.txt'), 'dos');
+        const mod = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        expect(mod).not.toBe(base);
+        git(repo, 'checkout', '-q', '--', '.');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'nuevo.txt'), 'x');
+        const untracked = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        expect(untracked).not.toBe(base);
+        fs_1.default.rmSync(path_1.default.join(repo, 'nuevo.txt'));
+        const otherCmd = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'run', 'lint'], [], '.').fingerprint;
+        expect(otherCmd).not.toBe(base);
+    });
+    test('cambio staged-only altera el fingerprint — indice real hasheado (R3.4)', () => {
+        const base = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'a.txt'), 'dos');
+        git(repo, 'add', 'a.txt');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'a.txt'), 'uno'); // worktree identico al base; SOLO el indice cambio
+        const stagedOnly = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        expect(stagedOnly).not.toBe(base);
+    });
+    test('cwd distinto altera el fingerprint; cwd fuera del repo se rechaza (R3.4)', () => {
+        fs_1.default.mkdirSync(path_1.default.join(repo, 'sub'));
+        const root = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        const sub = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], 'sub').fingerprint;
+        expect(sub).not.toBe(root);
+        expect(() => (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '../fuera')).toThrow(/cwd/);
+        expect(() => (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '/abs')).toThrow(/cwd/);
+    });
+    test('cwd que escapa mediante symlink se rechaza antes de persistir o ejecutar', () => {
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-fp-outside-'));
+        fs_1.default.symlinkSync(outside, path_1.default.join(repo, 'escape'));
+        try {
+            expect(() => (0, fingerprint_1.computeFingerprint)(repo, ['pwd'], [], 'escape')).toThrow(/symlink|fuera del repo/);
+        }
+        finally {
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
+    test('la expansion de paths queda persistida y excluye .awm (R3.4)', () => {
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm', 'journal'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'journal', 'state.json'), '{}');
+        const r = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], ['a.txt'], '.');
+        expect(r.expandedPaths).toEqual(['a.txt']);
+        const all = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.');
+        expect(all.expandedPaths.some((p) => p.startsWith('.awm/'))).toBe(false);
+    });
+    test('globs declarados distintos no comparten fingerprint aunque hoy expandan al mismo archivo', () => {
+        const narrow = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], ['a.txt'], '.');
+        const broad = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], ['*.txt'], '.');
+        expect(narrow.expandedPaths).toEqual(broad.expandedPaths);
+        expect(narrow.fingerprint).not.toBe(broad.fingerprint);
+    });
+    test('archivo con nombre no-ASCII: cambio de contenido SI altera el fingerprint (R3.4)', () => {
+        const name = 'café.txt';
+        fs_1.default.writeFileSync(path_1.default.join(repo, name), 'v1');
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c2');
+        const base = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        fs_1.default.writeFileSync(path_1.default.join(repo, name), 'v2-completely-different-content');
+        const mod = (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.').fingerprint;
+        expect(mod).not.toBe(base);
+    });
+    test('repos con muchos archivos no truncan la salida de git (R3.4)', () => {
+        for (let i = 0; i < 200; i++)
+            fs_1.default.writeFileSync(path_1.default.join(repo, `f${i}.txt`), `contenido-${i}`);
+        expect(() => (0, fingerprint_1.computeFingerprint)(repo, ['npm', 'test'], [], '.')).not.toThrow();
+    });
+});
+/** Defense-in-depth (post-implementation-qa, follow-up a Task 20): el `git()`
+ *  interno de este archivo backea `computeFingerprint`, invocado en CADA tick
+ *  del supervisor via `FingerprintNow`/`computeGate` (job/gate.ts). Sin stdio
+ *  explicito, `execFileSync` relayea el stderr de git hacia el stderr DEL
+ *  SUPERVISOR (`inheritStderr`, el default de Node cuando no se pasa `stdio`)
+ *  — si ese fd fuera un pipe roto/destruido, el relay mismo dispara un `write
+ *  EPIPE` no catcheable (throw asincronico via el evento 'error' del stream,
+ *  invisible a try/catch sincronico) que tumbaria TODO el proceso `awm watch`
+ *  en el tick siguiente, no solo un job. Este test reproduce esa condicion
+ *  contra el `dist/` compilado REAL: un hijo real con stdio pipe cuyos
+ *  extremos el padre destruye, corriendo `computeFingerprint` contra un `git`
+ *  stub que emite ruido a stderr en cada invocacion (simulando warnings/locale
+ *  de un git real) — sin el fix, esto tumba al hijo; con el fix, sobrevive. */
+describe('fingerprint.ts git(): stdio explicito evita inheritStderr hacia un pipe roto', () => {
+    const DIST_ENTRY = path_1.default.resolve(__dirname, '..', '..', '..', 'dist', 'src', 'core', 'journal', 'fingerprint.js');
+    const REAL_GIT = (0, child_process_1.execFileSync)('which', ['git'], { encoding: 'utf8' }).trim();
+    beforeAll(() => {
+        if (!fs_1.default.existsSync(DIST_ENTRY)) {
+            throw new Error('dist ausente: corre `cd cli && npm run build` antes de este test (verifica el dist compilado real, no el source transpilado por ts-jest)');
+        }
+    });
+    test('computeFingerprint sobrevive un git que escribe a stderr, corriendo en un hijo con stdio pipe destruido por su padre (regresion: inheritStderr de execFileSync sin stdio explicito)', async () => {
+        const workDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-fp-execfilesync-hardening-'));
+        const repoDir = path_1.default.join(workDir, 'repo');
+        fs_1.default.mkdirSync(repoDir);
+        (0, child_process_1.execFileSync)(REAL_GIT, ['init', '-q'], { cwd: repoDir });
+        (0, child_process_1.execFileSync)(REAL_GIT, ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '--allow-empty', '-qm', 'c1'], { cwd: repoDir });
+        fs_1.default.writeFileSync(path_1.default.join(repoDir, 'a.txt'), 'contenido');
+        // git "real" que, ademas de delegar al git del sistema, tambien emite
+        // algo en stderr en TODA invocacion — plausible en entornos reales
+        // (locale warnings, hooks, etc.) y suficiente para ejercitar inheritStderr.
+        const stubBin = path_1.default.join(workDir, 'git');
+        fs_1.default.writeFileSync(stubBin, `#!/bin/sh\necho "warning: ruido de stderr" 1>&2\nexec "${REAL_GIT}" "$@"\n`, { mode: 0o755 });
+        const outFile = path_1.default.join(workDir, 'out.txt');
+        const childScript = path_1.default.join(workDir, 'child.js');
+        fs_1.default.writeFileSync(childScript, `
+            const fs = require('fs');
+            const { computeFingerprint } = require(${JSON.stringify(DIST_ENTRY)});
+            try {
+                const result = computeFingerprint(${JSON.stringify(repoDir)}, ['npm', 'test'], [], '.');
+                fs.writeFileSync(${JSON.stringify(outFile)}, 'RESULT:' + result.fingerprint);
+            } catch (e) {
+                fs.writeFileSync(${JSON.stringify(outFile)}, 'THREW:' + e.message);
+            }
+        `);
+        const child = (0, child_process_1.spawn)(process.execPath, [childScript], {
+            cwd: workDir,
+            env: { ...process.env, PATH: `${workDir}:${process.env.PATH}` },
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: true,
+        });
+        // El patron exacto que causaba el crash original: el padre destruye
+        // su extremo de los pipes del hijo, cerrando el read-end — cualquier
+        // escritura del hijo a su propio stdout/stderr despues de esto EPIPE-ea.
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        const exit = await new Promise((resolve) => {
+            child.on('exit', (code, signal) => resolve({ code, signal }));
+        });
+        expect(exit.signal).toBeNull();
+        expect(exit.code).toBe(0); // el hijo debe sobrevivir y salir limpio, NO crashear por EPIPE no catcheable
+        const out = fs_1.default.readFileSync(outFile, 'utf8');
+        expect(out.startsWith('RESULT:')).toBe(true); // logica de negocio intacta: computeFingerprint devolvio normalmente
+        fs_1.default.rmSync(workDir, { recursive: true, force: true });
+    });
+});

package/dist/tests/core/journal/paths.test.js

@@ -0,0 +1,35 @@
+"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 paths_1 = require("../../../src/core/journal/paths");
+describe('journal paths', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-jpaths-')); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('branchSlug sanea separadores', () => {
+        expect((0, paths_1.branchSlug)('claude/mi-rama')).toBe('claude_2Fmi-rama');
+    });
+    test('branchSlug es biyectivo: ramas distintas no colisionan (R1.1)', () => {
+        expect((0, paths_1.branchSlug)('a/b')).not.toBe((0, paths_1.branchSlug)('a_b'));
+        expect((0, paths_1.branchSlug)('a/b')).not.toBe((0, paths_1.branchSlug)('a__b'));
+    });
+    test('journalDir es por-rama; el lock vive FUERA del dir de rama (R1.1)', () => {
+        const jd = (0, paths_1.journalDir)(repo, 'a/b');
+        const lock = (0, paths_1.supervisorLockPath)(repo);
+        expect(jd).toBe(path_1.default.join(repo, '.awm', 'journal', 'a_2Fb'));
+        expect(lock).toBe(path_1.default.join(fs_1.default.realpathSync(repo), '.awm', 'journal', 'supervisor.lock'));
+        expect(path_1.default.dirname(lock)).not.toBe(jd);
+    });
+    test('supervisorLockPath resuelve symlinks del worktree (R1.1)', () => {
+        const real = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-real-'));
+        const link = path_1.default.join(repo, 'link');
+        fs_1.default.symlinkSync(real, link);
+        expect((0, paths_1.supervisorLockPath)(link)).toBe(path_1.default.join(fs_1.default.realpathSync(real), '.awm', 'journal', 'supervisor.lock'));
+        fs_1.default.rmSync(real, { recursive: true, force: true });
+    });
+});