agentic-workflow-manager 6.2.1 → 6.3.0

package/dist/tests/commands/watch/track-teardown-crash.test.js

@@ -0,0 +1,426 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Task 13 (R4.2/R4.3/R4.6/R4.10/C2/C9): crash/restart del teardown durable de
+// UN track, con git REAL (mismo criterio que `track-bootstrap-crash.test.ts`,
+// Task 9, y `track-join-crash.test.ts`, Task 11 — Tasks 8-12 establecieron el
+// precedente de probar convergencia de crash contra un repo/worktree real,
+// no fakes en memoria). `runBeginTeardown` garantiza, por construcción, "a lo
+// sumo UN efecto real por invocación, persistido antes de seguir" (ver su
+// comentario grande en `tracks.ts`) — así que cada uno de los 8 puntos del
+// plan se representa fijando el journal EXACTAMENTE como quedaría tras un
+// crash real justo ahí (mismo patrón que `setPhase`/las manipulaciones
+// directas de `track-bootstrap-crash.test.ts` para los puntos "efecto real
+// ya corrió, resultado todavía no persistido"), y verificando que un
+// `reconcileTracks` fresco (runtime NUEVO, journal persistido intacto)
+// converge a `REMOVED` con el worktree y la branch REALMENTE ausentes.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const git_fixture_1 = require("../../helpers/git-fixture");
+const tracks_1 = require("../../../src/commands/watch/tracks");
+const store_1 = require("../../../src/core/journal/store");
+const git_1 = require("../../../src/core/tracks/git");
+const descriptor_1 = require("../../../src/core/tracks/descriptor");
+const BRANCH = 'main';
+/** Identidad que `refIsAlive` (identity-verified, R4.8) SIEMPRE reporta como
+ *  muerta: ningún proceso real jamás matchea estos campos fabricados — usada
+ *  para representar "el supervisor propio ya está confirmado ausente"
+ *  (idéntico efecto observable que si `stopOwnSupervisor` realmente hubiera
+ *  corrido y confirmado, sin depender de matar un proceso real). */
+function deadRef() {
+    return { pid: 999999, startTime: 'nunca-existió', spawnNonce: 'x', argvDigest: 'x', processGroup: 999999, psArgsDigest: 'dead' };
+}
+/** Runtime de producción para worktree/branch Y para `stopOwnSupervisor`
+ *  (git real y `terminatePreviouslyOwnedGroup` real vía `defaultTrackRuntime`
+ *  — post-review (hallazgo de revisión de Task 13): un fake que nunca llama
+ *  al primitivo real no puede probar la propiedad de seguridad
+ *  "ninguna señal alcanza un proceso ajeno" para el camino que de verdad
+ *  corre en producción). Con `deadRef()` esto sigue resolviendo por el atajo
+ *  de `groupIsGone` (pid 999999 no existe de verdad) — cero espera, mismo
+ *  comportamiento observable que el fake anterior — pero ahora es el código
+ *  real, no una simulación. Ningún otro método de `TrackRuntime` debería
+ *  invocarse — esta suite solo ejercita `begin-teardown`. */
+function buildRuntime(planRoot, events) {
+    const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+    const unexpected = (what) => () => {
+        throw new Error(`no debería llamarse: ${what} (esta suite solo ejercita begin-teardown)`);
+    };
+    return {
+        addWorktree: unexpected('addWorktree'),
+        initTrackJournal: unexpected('initTrackJournal'),
+        spawnSupervisor: unexpected('spawnSupervisor'),
+        observeSupervisor: unexpected('observeSupervisor'),
+        async stopOwnSupervisor(ref) {
+            const confirmed = await real.stopOwnSupervisor(ref);
+            events.push(`stop-effect:${ref.trackId}`);
+            return confirmed;
+        },
+        removeOwnedWorktree(repo, ref) {
+            real.removeOwnedWorktree(repo, ref);
+            events.push(`worktree-effect:${ref.trackId}`);
+        },
+        removeOwnedBranch(repo, branch) {
+            real.removeOwnedBranch(repo, branch);
+            events.push(`branch-effect:${branch}`);
+        },
+        emitFreezeRequest: unexpected('emitFreezeRequest'),
+        mergeFrozenTrack: unexpected('mergeFrozenTrack'),
+        abortOwnedMerge: unexpected('abortOwnedMerge'),
+        async ensureIntegrationLock() { return unexpected('ensureIntegrationLock')(); },
+        async pauseControllerGeneration() { return unexpected('pauseControllerGeneration')(); },
+        releaseIntegrationLockIfHeld: unexpected('releaseIntegrationLockIfHeld'),
+    };
+}
+function declareCohort(planRoot, root, baseSha) {
+    (0, store_1.initJournal)(planRoot, BRANCH);
+    const s0 = (0, store_1.readJournal)(planRoot, BRANCH).state;
+    s0.cohortPhase = 'FALLBACK_PENDING';
+    s0.cohortBaseSha = baseSha;
+    s0.tracks = [
+        {
+            trackId: 'a', worktreePath: path_1.default.join(root, 'track-a'), branch: 'awm-track/a',
+            ownership: [], sharedResources: [], dependsOn: [],
+            fencingToken: 'fa'.padEnd(32, '0'), phase: 'DECLARED', readinessNonce: 'ra'.padEnd(32, '0'),
+        },
+        // 'b' se queda en DECLARED siempre: `nextProtocolEffect` (FALLBACK_PENDING)
+        // solo elige un track a la vez, alfabéticamente — jamás toca 'b'
+        // mientras 'a' no llegue a REMOVED.
+        {
+            trackId: 'b', worktreePath: path_1.default.join(root, 'track-b'), branch: 'awm-track/b',
+            ownership: [], sharedResources: [], dependsOn: [],
+            fencingToken: 'fb'.padEnd(32, '0'), phase: 'DECLARED', readinessNonce: 'rb'.padEnd(32, '0'),
+        },
+    ];
+    (0, store_1.writeJournal)(planRoot, BRANCH, s0);
+    return (0, store_1.readJournal)(planRoot, BRANCH).state;
+}
+function setTrackA(planRoot, patch) {
+    const s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+    s.tracks = s.tracks.map((t) => (t.trackId === 'a' ? { ...t, ...patch } : t));
+    (0, store_1.writeJournal)(planRoot, BRANCH, s);
+    return (0, store_1.readJournal)(planRoot, BRANCH).state;
+}
+function trackA(s) {
+    return s.tracks.find((t) => t.trackId === 'a');
+}
+function realWorktreeBranches(planRoot) {
+    let out;
+    try {
+        out = (0, child_process_1.execFileSync)('git', ['worktree', 'list', '--porcelain'], { cwd: planRoot, encoding: 'utf8' });
+    }
+    catch {
+        return [];
+    }
+    const branches = [];
+    for (const line of out.split('\n')) {
+        if (line.startsWith('branch '))
+            branches.push(line.slice('branch '.length).replace('refs/heads/', ''));
+    }
+    return branches;
+}
+function branchListed(planRoot, branch) {
+    const out = (0, child_process_1.execFileSync)('git', ['branch', '--list', branch], { cwd: planRoot, encoding: 'utf8' });
+    return out.trim().length > 0;
+}
+describe('reconcileTracks — crash/restart de teardown con git real (Task 13, R4.2/R4.3/R4.6/R4.10/C2/C9)', () => {
+    let root;
+    let planRoot;
+    let baseSha;
+    beforeEach(() => {
+        planRoot = (0, git_fixture_1.initRepo)();
+        (0, git_fixture_1.commitFile)(planRoot, '.gitignore', '.awm/\n');
+        baseSha = (0, git_fixture_1.commitFile)(planRoot, 'seed.txt', 'seed');
+        root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-teardown-crash-root-'));
+    });
+    afterEach(() => {
+        try {
+            (0, child_process_1.execFileSync)('git', ['worktree', 'prune'], { cwd: planRoot, stdio: 'pipe' });
+        }
+        catch { /* best-effort */ }
+        fs_1.default.rmSync(planRoot, { recursive: true, force: true });
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    /** Materializa el worktree+branch REALES de 'a' (git de verdad) y su
+     *  descriptor `.awm/track.json` — la prueba de ownership que
+     *  `worktreeOwnershipProven` exige antes de `remove-owned-worktree`. */
+    function materializeTrackA(s) {
+        const ref = trackA(s);
+        (0, git_1.addOwnedWorktree)(planRoot, ref, baseSha);
+        (0, descriptor_1.writeDescriptor)(ref.worktreePath, {
+            schema: 1, planRoot: fs_1.default.realpathSync(planRoot), planBranch: BRANCH,
+            trackId: ref.trackId, planJournalId: s.journalId, fencingToken: ref.fencingToken,
+        });
+    }
+    const teardownCrashPoints = [
+        'after-teardown-request', 'after-teardown-intent', 'after-stop-effect',
+        'after-supervisor-stopped', 'after-worktree-effect', 'after-worktree-removed',
+        'after-branch-effect', 'after-branch-removed',
+    ];
+    /** Deja el journal EXACTAMENTE como quedaría tras un crash real justo
+     *  después del punto nombrado — mismo criterio que `setPhase` en
+     *  `track-bootstrap-crash.test.ts`: para los puntos donde el efecto real
+     *  YA corrió pero `tracks.ts` no llegó a persistir la observación
+     *  (`after-stop-effect`, `after-worktree-effect`, `after-branch-effect`),
+     *  se reproduce la mutación real fuera de `reconcileTracks` y se
+     *  mantiene la fase ANTERIOR — el próximo tick debe volver a observar el
+     *  mundo real (no confiar en memoria) para converger. */
+    function setupAt(point) {
+        let s = declareCohort(planRoot, root, baseSha);
+        materializeTrackA(s);
+        s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        const ref = trackA(s);
+        if (point === 'after-teardown-request') {
+            return setTrackA(planRoot, { phase: 'TEARDOWN_REQUESTED', supervisorProcessRef: deadRef() });
+        }
+        const teardownIntent = { worktreePath: ref.worktreePath, branch: ref.branch, supervisorNonce: undefined };
+        if (point === 'after-teardown-intent') {
+            return setTrackA(planRoot, { phase: 'TEARDOWN_INTENT', teardownIntent, supervisorProcessRef: deadRef() });
+        }
+        if (point === 'after-stop-effect') {
+            // El efecto de stop YA corrió y el mundo real ya muestra al
+            // supervisor confirmado ausente (`deadRef`) — pero la fase
+            // TODAVÍA no avanzó a SUPERVISOR_STOPPED (crash justo ahí).
+            return setTrackA(planRoot, { phase: 'TEARDOWN_INTENT', teardownIntent, supervisorProcessRef: deadRef() });
+        }
+        if (point === 'after-supervisor-stopped') {
+            return setTrackA(planRoot, { phase: 'SUPERVISOR_STOPPED', teardownIntent, supervisorProcessRef: deadRef() });
+        }
+        if (point === 'after-worktree-effect') {
+            // El worktree YA se removió de verdad (fuera de `reconcileTracks`,
+            // mismo criterio que `after-worktree-effect` de Task 9), pero la
+            // fase todavía dice SUPERVISOR_STOPPED.
+            (0, git_1.removeOwnedWorktree)(planRoot, ref.worktreePath);
+            return setTrackA(planRoot, { phase: 'SUPERVISOR_STOPPED', teardownIntent, supervisorProcessRef: deadRef() });
+        }
+        if (point === 'after-worktree-removed') {
+            (0, git_1.removeOwnedWorktree)(planRoot, ref.worktreePath);
+            return setTrackA(planRoot, { phase: 'WORKTREE_REMOVED', teardownIntent, supervisorProcessRef: deadRef() });
+        }
+        if (point === 'after-branch-effect') {
+            (0, git_1.removeOwnedWorktree)(planRoot, ref.worktreePath);
+            (0, git_1.removeOwnedBranch)(planRoot, ref.branch);
+            return setTrackA(planRoot, { phase: 'WORKTREE_REMOVED', teardownIntent, supervisorProcessRef: deadRef() });
+        }
+        // 'after-branch-removed'
+        (0, git_1.removeOwnedWorktree)(planRoot, ref.worktreePath);
+        (0, git_1.removeOwnedBranch)(planRoot, ref.branch);
+        return setTrackA(planRoot, { phase: 'BRANCH_REMOVED', teardownIntent, supervisorProcessRef: deadRef() });
+    }
+    test.each(teardownCrashPoints)('teardown converge desde %s (C9)', async (point) => {
+        let s = setupAt(point);
+        const events = [];
+        // "Restart" tras el crash: runtime NUEVO (misma disciplina que
+        // `track-bootstrap-crash.test.ts` — instrumentación fresca salvo lo
+        // que sobreviviría de verdad a un crash real, que acá es el propio
+        // repo git). Reconciliar hasta REMOVED o hasta agotar un límite
+        // generoso de ticks (cada tick es a lo sumo UNA frontera real).
+        const runtime = buildRuntime(planRoot, events);
+        for (let i = 0; i < 20 && trackA(s).phase !== 'REMOVED'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        expect(trackA(s).phase).toBe('REMOVED');
+        expect(trackA(s).blockedReason).toBeUndefined();
+        // Prueba REAL (no solo el journal): el worktree y la branch de 'a'
+        // están genuinamente ausentes del repo.
+        expect(fs_1.default.existsSync(path_1.default.join(root, 'track-a'))).toBe(false);
+        expect(realWorktreeBranches(planRoot)).not.toContain('awm-track/a');
+        expect(branchListed(planRoot, 'awm-track/a')).toBe(false);
+        // 'b' (DECLARED, nunca tocado) permanece exactamente como se declaró.
+        const b = s.tracks.find((t) => t.trackId === 'b');
+        expect(b.phase).toBe('DECLARED');
+        expect(fs_1.default.existsSync(path_1.default.join(root, 'track-b'))).toBe(false);
+    });
+    // Step 4 del plan ("supervisor propio muerto confirmado Y lock ausente"):
+    // un lock advisory que el supervisor dejó sin liberar (crash a mitad de
+    // su propia salida) nunca debe atascar el teardown para siempre — una
+    // vez que su grupo entero está confirmado ausente por identidad, el lock
+    // es demostrablemente stale (vive en el worktree PROPIO del track) y se
+    // reclama. Usa `defaultTrackRuntime` de PRODUCCIÓN (no el fake de esta
+    // suite) para probar el efecto real de `stopOwnSupervisor`.
+    test('lock advisory stale (supervisor muerto sin liberarlo) se reclama y el teardown converge (C9)', async () => {
+        let s = declareCohort(planRoot, root, baseSha);
+        materializeTrackA(s);
+        s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        const ref = trackA(s);
+        const lockPath = path_1.default.join(ref.worktreePath, '.awm', 'journal', 'supervisor.lock');
+        fs_1.default.mkdirSync(path_1.default.dirname(lockPath), { recursive: true });
+        fs_1.default.writeFileSync(lockPath, 'lock stale de un supervisor que crasheó sin liberar\n');
+        s = setTrackA(planRoot, {
+            phase: 'TEARDOWN_INTENT',
+            teardownIntent: { worktreePath: ref.worktreePath, branch: ref.branch, supervisorNonce: undefined },
+            supervisorProcessRef: deadRef(), // proceso confirmado muerto: solo el lock lo retiene
+        });
+        const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+        for (let i = 0; i < 20 && trackA(s).phase !== 'REMOVED'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        expect(trackA(s).phase).toBe('REMOVED');
+        expect(fs_1.default.existsSync(lockPath)).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(root, 'track-a'))).toBe(false);
+        expect(branchListed(planRoot, 'awm-track/a')).toBe(false);
+    });
+    // R4.6/R4.10/C9: un worktree cuyo ownership es indemostrable (descriptor
+    // ausente/corrupto, o simplemente no es el que `teardownIntent` espera)
+    // NUNCA se adopta ni se borra — el track se bloquea, y el contenido
+    // "ajeno" permanece byte-idéntico. `BLOCKED` es un dead end automático
+    // (ver `decideTeardown`): reconciliar de nuevo, cuantas veces sea, jamás
+    // lo saca solo de ahí.
+    test('worktree con ownership indemostrable bloquea SIN tocarlo — el fixture ajeno queda byte-idéntico (R4.6, R4.10, C9)', async () => {
+        let s = declareCohort(planRoot, root, baseSha);
+        const ref = trackA(s);
+        // El path existe (registrado como worktree real por git, igual que
+        // uno legítimamente propio) pero SIN el descriptor `.awm/track.json`
+        // que probaría identidad — `worktreeOwnershipProven` debe fallar.
+        (0, git_1.addOwnedWorktree)(planRoot, ref, baseSha);
+        const marker = path_1.default.join(ref.worktreePath, 'foreign.marker');
+        fs_1.default.writeFileSync(marker, 'contenido ajeno, nunca tocar\n');
+        const markerBytesBefore = fs_1.default.readFileSync(marker);
+        s = setTrackA(planRoot, {
+            phase: 'SUPERVISOR_STOPPED',
+            teardownIntent: { worktreePath: ref.worktreePath, branch: ref.branch, supervisorNonce: undefined },
+            supervisorProcessRef: deadRef(),
+        });
+        const events = [];
+        const runtime = buildRuntime(planRoot, events);
+        for (let i = 0; i < 5; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        expect(trackA(s).phase).toBe('BLOCKED');
+        expect(trackA(s).blockedReason).toBe('worktree preexistente ajeno');
+        // Nunca se llamó al efecto real de remoción — ownership nunca se probó.
+        expect(events).toEqual([]);
+        // El worktree y su contenido siguen ahí, byte por byte.
+        expect(fs_1.default.existsSync(ref.worktreePath)).toBe(true);
+        expect(fs_1.default.readFileSync(marker)).toEqual(markerBytesBefore);
+        expect(realWorktreeBranches(planRoot)).toContain('awm-track/a');
+        // BLOCKED es un dead end AUTOMÁTICO: más reconciliaciones no lo mueven.
+        const again = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2);
+        expect(trackA(again.state).phase).toBe('BLOCKED');
+        expect(fs_1.default.readFileSync(marker)).toEqual(markerBytesBefore);
+    });
+    // Post-review (hallazgo de revisión de Task 13): la prueba literal que el
+    // sketch del plan (Step 5) pedía — `h.signalledForeignProcess()).toBe(false)`
+    // — y que esta suite nunca ejercitaba porque `stopOwnSupervisor` era
+    // 100% fake. `supervisorProcessRef` en el journal describe un supervisor
+    // previo ya extinto cuyo pgid el SO recicló (simulado, mismo criterio que
+    // el fixture R6 de `process.test.ts`) hacia `bystander`, un proceso REAL,
+    // vivo y completamente ajeno.
+    //
+    // Con `defaultTrackRuntime` real, esta identidad-fabricada NUNCA llega a
+    // `stopOwnSupervisor`/`terminatePreviouslyOwnedGroup`: `gatherTeardownObservation`
+    // ya usa `refIsAlive` (identidad completa) para decidir `ownSupervisorAlive`
+    // en la MISMA tick, así que un pgid reciclado con identidad distinta se
+    // reporta como "nuestro supervisor ya está muerto" y el teardown avanza
+    // por `accept-supervisor-stopped` — nunca por `stop-own-supervisor` — sin
+    // jamás tocar al bystander (defensa en profundidad ya existente, ver el
+    // comentario de `gatherTeardownObservation`). Esta prueba confirma esa
+    // propiedad end-to-end (converge a REMOVED sin señal alguna al ajeno); la
+    // prueba siguiente confirma la MISMA propiedad un nivel más abajo, en el
+    // primitivo `defaultTrackRuntime(...).stopOwnSupervisor` en sí mismo (el
+    // fix real de `groupLeaderReused` en `process.ts`), sin depender de esa
+    // capa superior.
+    test('supervisor propio con PGID reciclado por un proceso ajeno: el teardown converge sin jamás señalizarlo (R4.8, post-review)', async () => {
+        let s = declareCohort(planRoot, root, baseSha);
+        materializeTrackA(s);
+        s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        const ref = trackA(s);
+        // Vive hasta que el `finally` lo mate, NO 5 segundos. Estos dos tests son los
+        // únicos de la suite que asertan que el proceso ajeno SIGUE VIVO al final, y un
+        // tiempo fijo convierte esa aserción en una carrera contra la plataforma más lenta:
+        // en Windows este archivo tarda ~22s, así que el bystander moría de viejo y el test
+        // reportaba "lo matamos" cuando `signalledForeignProcess` probaba lo contrario.
+        // Se elimina la carrera en vez de agrandarle el margen.
+        const bystander = (0, child_process_1.spawn)(process.execPath, ['-e', 'setInterval(()=>{}, 1000)'], { detached: true, stdio: 'ignore' });
+        if (bystander.pid === undefined)
+            throw new Error('spawn de bystander falló');
+        const bystanderPid = bystander.pid;
+        await new Promise((resolve) => setTimeout(resolve, 150)); // dejar asentar identidad real vía ps
+        const staleSupervisorRef = {
+            pid: bystanderPid,
+            startTime: 'Mon Jan  1 00:00:00 2024', // supervisor anterior, ya extinto
+            spawnNonce: 'nonce-de-un-supervisor-anterior-ya-muerto',
+            argvDigest: 'deadbeefdeadbeef',
+            processGroup: bystanderPid, // MISMO número de pgid (reciclado)
+            psArgsDigest: 'cafebabecafebabe',
+        };
+        s = setTrackA(planRoot, {
+            phase: 'TEARDOWN_INTENT',
+            teardownIntent: { worktreePath: ref.worktreePath, branch: ref.branch, supervisorNonce: undefined },
+            supervisorProcessRef: staleSupervisorRef,
+        });
+        const killSpy = jest.spyOn(process, 'kill');
+        try {
+            const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH, { termGraceMs: 100, killGraceMs: 100 });
+            for (let i = 0; i < 20 && trackA(s).phase !== 'REMOVED'; i++) {
+                s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+            }
+            // La propiedad que vale en TODAS las plataformas y es la razón de ser del test:
+            // el proceso ajeno JAMÁS recibe una señal. Se afirma primero, sin condicionar.
+            const signalledForeignProcess = killSpy.mock.calls.some(([target]) => Number(target) === -bystanderPid);
+            expect(signalledForeignProcess).toBe(false);
+            // La convergencia a REMOVED, en cambio, es POSIX-only y por diseño: en win32
+            // `refIsAlive` no consulta identidad (decisión deliberada de Ronda 3 — ps/pgrep
+            // de MSYS son ciegos a procesos nativos y declaraban muertes falsas), así que un
+            // pid reciclado se lee como "nuestro supervisor sigue vivo" y el teardown espera.
+            // Sobre-reportar vida es la dirección segura: nunca mata nada ajeno, solo espera.
+            // Afirmar REMOVED en win32 exigiría revertir esa decisión para que un test pase.
+            if (process.platform !== 'win32')
+                expect(trackA(s).phase).toBe('REMOVED');
+            // El bystander sigue vivo: nunca fue tocado.
+            expect(() => process.kill(bystanderPid, 0)).not.toThrow();
+        }
+        finally {
+            killSpy.mockRestore();
+            bystander.kill('SIGKILL');
+        }
+    });
+    // Complemento de la prueba anterior, un nivel más abajo: llama
+    // directamente a `defaultTrackRuntime(...).stopOwnSupervisor` (el mismo
+    // primitivo que `runBeginTeardown` invoca en producción para la decisión
+    // `stop-own-supervisor`), sin pasar por `gatherTeardownObservation`. Esto
+    // prueba el fix de `groupLeaderReused` (`process.ts`) en sí mismo — que
+    // el PRIMITIVO, no solo la capa de arriba, se niega a señalizar un pgid
+    // reciclado por un proceso ajeno vivo.
+    test('defaultTrackRuntime.stopOwnSupervisor jamás señaliza un pgid reciclado por un proceso ajeno, aunque se lo invoque directo (R4.8, post-review)', async () => {
+        let s = declareCohort(planRoot, root, baseSha);
+        materializeTrackA(s);
+        s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        const ref = trackA(s);
+        // Vive hasta que el `finally` lo mate, NO 5 segundos. Estos dos tests son los
+        // únicos de la suite que asertan que el proceso ajeno SIGUE VIVO al final, y un
+        // tiempo fijo convierte esa aserción en una carrera contra la plataforma más lenta:
+        // en Windows este archivo tarda ~22s, así que el bystander moría de viejo y el test
+        // reportaba "lo matamos" cuando `signalledForeignProcess` probaba lo contrario.
+        // Se elimina la carrera en vez de agrandarle el margen.
+        const bystander = (0, child_process_1.spawn)(process.execPath, ['-e', 'setInterval(()=>{}, 1000)'], { detached: true, stdio: 'ignore' });
+        if (bystander.pid === undefined)
+            throw new Error('spawn de bystander falló');
+        const bystanderPid = bystander.pid;
+        await new Promise((resolve) => setTimeout(resolve, 150));
+        const staleSupervisorRef = {
+            pid: bystanderPid,
+            startTime: 'Mon Jan  1 00:00:00 2024',
+            spawnNonce: 'nonce-de-un-supervisor-anterior-ya-muerto',
+            argvDigest: 'deadbeefdeadbeef',
+            processGroup: bystanderPid,
+            psArgsDigest: 'cafebabecafebabe',
+        };
+        const killSpy = jest.spyOn(process, 'kill');
+        try {
+            const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH, { termGraceMs: 100, killGraceMs: 100 });
+            const confirmed = await runtime.stopOwnSupervisor({ ...ref, supervisorProcessRef: staleSupervisorRef });
+            expect(confirmed).toBe(false); // fail-closed: nunca declara "confirmado ausente" arriesgando un ajeno
+            const signalledForeignProcess = killSpy.mock.calls.some(([target]) => Number(target) === -bystanderPid);
+            expect(signalledForeignProcess).toBe(false);
+            expect(() => process.kill(bystanderPid, 0)).not.toThrow();
+        }
+        finally {
+            killSpy.mockRestore();
+            bystander.kill('SIGKILL');
+        }
+    });
+});

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// R5 Task 16 (cierre por controller scripteado): `AWM_CONTROLLER_ARGV` es lo que vuelve
+// FALSIFICABLE la afirmacion "el supervisor no conoce providers". Sin este seam, los unicos
+// controllers posibles eran `codex` y `claude-code`, asi que la agnosticidad no se podia
+// comprobar ni romper — solo creer.
+const adapter_1 = require("../../../src/core/journal/adapter");
+describe('adapterFor · override de argv del controller', () => {
+    const previous = process.env[adapter_1.CONTROLLER_ARGV_ENV];
+    afterEach(() => {
+        if (previous === undefined)
+            delete process.env[adapter_1.CONTROLLER_ARGV_ENV];
+        else
+            process.env[adapter_1.CONTROLLER_ARGV_ENV] = previous;
+    });
+    it('sin override, cada provider conserva su argv nativo', () => {
+        delete process.env[adapter_1.CONTROLLER_ARGV_ENV];
+        expect((0, adapter_1.adapterFor)('codex').launchArgv('P')[0]).toBe('codex');
+        expect((0, adapter_1.adapterFor)('claude-code').launchArgv('P')[0]).toBe('claude');
+    });
+    it('con override, el prompt viaja como ULTIMO argumento — el token llega igual', () => {
+        process.env[adapter_1.CONTROLLER_ARGV_ENV] = JSON.stringify(['node', '/tmp/ctl.mjs', '--flag']);
+        const argv = (0, adapter_1.adapterFor)('codex').launchArgv('Generacion activa: abc123');
+        expect(argv).toEqual(['node', '/tmp/ctl.mjs', '--flag', 'Generacion activa: abc123']);
+    });
+    it('el override NO reemplaza el resto del adapter (fencing/custodia siguen siendo del provider)', () => {
+        process.env[adapter_1.CONTROLLER_ARGV_ENV] = JSON.stringify(['node', 'ctl.mjs']);
+        const a = (0, adapter_1.adapterFor)('claude-code');
+        expect(a.provider).toBe('claude-code');
+        // `safeToReplace` es la señal POSITIVA que decide si el supervisor releva o entra en
+        // custodia. Si el override la tocara, un controller scripteado podría autorizar un
+        // relevo que el provider real nunca autorizaría — el seam quedaría mintiendo.
+        expect(a.safeToReplace).toBe((0, adapter_1.adapterFor)('codex').safeToReplace);
+    });
+    it.each([
+        ['claude -p "hola"', 'una linea de shell'],
+        ['[]', 'array vacio'],
+        ['["node", ""]', 'string vacio'],
+        ['["node", 3]', 'elemento no-string'],
+        ['{"cmd":"node"}', 'objeto en vez de array'],
+    ])('rechaza %s (%s) en vez de caer al provider nativo', (raw) => {
+        process.env[adapter_1.CONTROLLER_ARGV_ENV] = raw;
+        // Fail-closed a propósito: un override mal escrito que "funciona igual" lanzaría el
+        // agente REAL — con su costo en tokens — sin que nadie note que el override no aplicó.
+        expect(() => (0, adapter_1.adapterFor)('codex')).toThrow(adapter_1.CONTROLLER_ARGV_ENV);
+    });
+    it('un override en blanco es ausencia, no error', () => {
+        process.env[adapter_1.CONTROLLER_ARGV_ENV] = '   ';
+        expect((0, adapter_1.adapterFor)('codex').launchArgv('P')[0]).toBe('codex');
+    });
+});

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

@@ -122,6 +122,43 @@ describe('process identity', () => {
         expect(dead).toBe(true);
         expect((0, process_1.groupIsGone)(ref.processGroup)).toBe(true);
     }, 15000);
+    test('terminatePreviouslyOwnedGroup jamas senializa un PGID reciclado por un proceso ajeno vivo (post-review, hallazgo de revision de Task 13)', async () => {
+        // Mismo criterio de simulacion deterministica que el fixture de R6 de
+        // mas arriba (`reusedPidStaleRef`): un proceso REAL y vivo ahora mismo
+        // (mismo pid/pgid), pero un ProcessRef que describe un "lider"
+        // DISTINTO y ya extinto que alguna vez tuvo ese mismo numero —
+        // startTime, nonce, argvDigest y psArgsDigest todos ajenos al
+        // proceso real que hoy ocupa ese slot. Antes del fix, la ausencia de
+        // este chequeo en `terminatePreviouslyOwnedGroup` (a diferencia de
+        // `terminateGroupConfirmed`, que sí verifica `refIsAlive`) habría
+        // enviado la señal directo a `-pgid`, alcanzando a este proceso
+        // ajeno.
+        const bystander = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'n-bystander');
+        const stalePriorLeaderRef = {
+            pid: bystander.ref.pid,
+            startTime: 'Mon Jan  1 00:00:00 2024', // "lider" anterior, ya extinto
+            spawnNonce: 'nonce-de-un-supervisor-anterior-ya-muerto',
+            argvDigest: 'deadbeefdeadbeef',
+            processGroup: bystander.ref.processGroup, // MISMO numero de pgid (reciclado)
+            psArgsDigest: 'cafebabecafebabe',
+        };
+        try {
+            const killSpy = jest.spyOn(process, 'kill');
+            try {
+                const confirmed = await (0, process_1.terminatePreviouslyOwnedGroup)(stalePriorLeaderRef, { termGraceMs: 50, killGraceMs: 50 });
+                expect(confirmed).toBe(false); // fail-closed: nunca declara "confirmado ausente" a costa de arriesgar un ajeno
+                const signalledForeignProcess = killSpy.mock.calls.some(([target]) => Number(target) === -bystander.ref.processGroup);
+                expect(signalledForeignProcess).toBe(false);
+            }
+            finally {
+                killSpy.mockRestore();
+            }
+            expect((0, process_1.refIsAlive)(bystander.ref)).toBe(true); // el ajeno sigue vivo, intacto
+        }
+        finally {
+            bystander.child.kill('SIGKILL');
+        }
+    });
     test('activitySnapshot reporta cpu y tamanio de grupo de un proceso vivo (soporte R4.2)', () => {
         const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 3000)'], process.cwd(), 'n4');
         const snap = (0, process_1.activitySnapshot)(ref);

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

@@ -131,4 +131,25 @@ describe('requests', () => {
         const listed = (0, requests_1.listPendingRequests)(repo, 'rama').map((p) => p.requestId);
         expect(listed.indexOf(idA)).toBeLessThan(listed.indexOf(idB));
     });
+    test('emitRequest soporta los nuevos kinds del protocolo de tracks (R9.2)', () => {
+        const kinds = [
+            'track-prepare-request', 'track-freeze-request', 'track-join-request',
+            'track-teardown-request', 'track-finalize-request',
+        ];
+        for (const kind of kinds) {
+            const r = (0, requests_1.emitRequest)(repo, 'rama', { kind, generationToken: 'g1', idempotencyKey: `k-${kind}`, payload: { trackId: 'cli' } });
+            const pending = (0, requests_1.listPendingRequests)(repo, 'rama').find((p) => p.requestId === r.requestId);
+            expect(pending?.corrupt).toBe(false);
+            expect(pending?.envelope.kind).toBe(kind);
+        }
+    });
+    test('un kind desconocido en el JSON se clasifica corrupto antes de consumirlo (R9.2)', () => {
+        const file = path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'unknown-kind.json');
+        fs_1.default.writeFileSync(file, JSON.stringify({
+            requestId: 'unknown-kind', kind: 'track-vaporize-request', generationToken: 'g1', idempotencyKey: 'k1', payload: {},
+        }));
+        const [pending] = (0, requests_1.listPendingRequests)(repo, 'rama');
+        expect(pending.corrupt).toBe(true);
+        expect(pending.requestId).toBe('unknown-kind.json');
+    });
 });

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

@@ -91,4 +91,32 @@ describe('journal store', () => {
         const wrongBranch = { ...s, branch: 'otra-rama' };
         expect(() => (0, store_1.writeJournal)(repo, 'rama', wrongBranch)).toThrow(/branch/);
     });
+    test('schema 1 legacy recibe journalId determinista sin perder evidencia (R9.3)', () => {
+        (0, store_1.initJournal)(repo, 'legacy');
+        const legacy = (0, store_1.readJournal)(repo, 'legacy').state;
+        delete legacy.journalId;
+        fs_1.default.writeFileSync((0, paths_1.statePath)(repo, 'legacy'), JSON.stringify(legacy));
+        const first = (0, store_1.readJournal)(repo, 'legacy').state;
+        const second = (0, store_1.readJournal)(repo, 'legacy').state;
+        expect(first.journalId).toBe(second.journalId);
+        expect(first.journalId).toMatch(/^legacy-[0-9a-f]{32}$/);
+    });
+    test('journalId legacy materializado se persiste en la siguiente escritura CAS normal (R9.3)', () => {
+        (0, store_1.initJournal)(repo, 'legacy2');
+        const legacy = (0, store_1.readJournal)(repo, 'legacy2').state;
+        delete legacy.journalId;
+        fs_1.default.writeFileSync((0, paths_1.statePath)(repo, 'legacy2'), JSON.stringify(legacy));
+        const read = (0, store_1.readJournal)(repo, 'legacy2').state;
+        // la lectura por si sola sigue siendo read-only: el disco AUN no tiene journalId
+        expect(JSON.parse(fs_1.default.readFileSync((0, paths_1.statePath)(repo, 'legacy2'), 'utf8')).journalId).toBeUndefined();
+        (0, store_1.writeJournal)(repo, 'legacy2', read);
+        const onDisk = JSON.parse(fs_1.default.readFileSync((0, paths_1.statePath)(repo, 'legacy2'), 'utf8'));
+        expect(onDisk.journalId).toBe(read.journalId);
+    });
+    test('normalizeSchemaOne no inventa tracks/trackContext para un journal legacy que nunca los tuvo (R9.2)', () => {
+        (0, store_1.initJournal)(repo, 'legacy3');
+        const read = (0, store_1.readJournal)(repo, 'legacy3').state;
+        expect(read.tracks).toBeUndefined();
+        expect(read.trackContext).toBeUndefined();
+    });
 });