agentic-workflow-manager 6.2.0 → 6.3.0

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

@@ -0,0 +1,439 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Task 11 (R6.2/R6.3/R6.6-R6.9/C7): crash/restart de P2 (join durable) contra
+// git REAL — mismo criterio que `track-bootstrap-crash.test.ts` (Task 9):
+// probar "sin doble merge" (C11-adjacent) solo tiene sentido mirando el
+// repo real, no eventos. Se reutiliza la MISMA instancia de `TrackRuntime`
+// (`defaultTrackRuntime`) a lo largo de "antes" y "después" del crash — el
+// "crash" se simula deteniendo los ticks y, cuando el efecto real ya ocurrió
+// pero no se persistió, reproduciéndolo a mano con las MISMAS funciones
+// reales (`mergeFrozenTrack`), exactamente como `buildRuntime`/`stopWhen` de
+// Task 9 reconstruyen el mundo tras un crash sin volver a levantar un
+// proceso nuevo (dentro de un mismo proceso Jest, un "proceso nuevo" real
+// para `integration.lock` reclamaría identidad viva-por-definición del pid
+// del test runner — no es lo que este archivo necesita probar; eso ya lo
+// cubre `join.test.ts`/Task 10 con `ProcessRef`s fabricados).
+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 git_1 = require("../../../src/core/tracks/git");
+const paths_1 = require("../../../src/core/journal/paths");
+const store_1 = require("../../../src/core/journal/store");
+const BRANCH = 'main';
+function gitLocal(repo, args) {
+    return (0, child_process_1.execFileSync)('git', args, { cwd: repo, encoding: 'utf8', stdio: 'pipe' });
+}
+function trackRef(id, overrides = {}) {
+    return {
+        trackId: id, worktreePath: `/nonexistent/${id}`, branch: `awm-track/${id}`,
+        ownership: [], sharedResources: [], dependsOn: [],
+        fencingToken: `fence-${id}`.padEnd(32, '0'), phase: 'FROZEN', readinessNonce: `ready-${id}`.padEnd(32, '0'),
+        ...overrides,
+    };
+}
+function mergeCommitCountFor(repo, trackHeadSha) {
+    let out;
+    try {
+        out = gitLocal(repo, ['log', '--all', '--format=%H %P']);
+    }
+    catch {
+        return 0;
+    }
+    return out.split('\n').filter((line) => line.trim().length > 0 && line.split(' ').slice(1).includes(trackHeadSha)).length;
+}
+describe('reconcileTracks — crash/restart de P2 (join) con git real (Task 11, R6.2/R6.3/R6.6-R6.9/C7)', () => {
+    let planRoot;
+    let root;
+    let baseSha;
+    beforeEach(() => {
+        planRoot = (0, git_fixture_1.initRepo)();
+        gitLocal(planRoot, ['config', 'user.email', 't@t.t']);
+        gitLocal(planRoot, ['config', 'user.name', 't']);
+        gitLocal(planRoot, ['config', 'commit.gpgsign', 'false']);
+        (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-join-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 });
+    });
+    /** Worktree REAL para un track — comparte el object store del repo del
+     *  plan (mismo `.git`), así que el SHA congelado queda alcanzable sin
+     *  fetch, exactamente como lo dejaría `addOwnedWorktree` en producción. */
+    function makeTrackHead(id, filename, content) {
+        const wt = path_1.default.join(root, `wt-${id}`);
+        gitLocal(planRoot, ['worktree', 'add', '-b', `awm-track/${id}`, wt, baseSha]);
+        fs_1.default.writeFileSync(path_1.default.join(wt, filename), content);
+        gitLocal(wt, ['add', '--', filename]);
+        gitLocal(wt, ['commit', '-qm', `track ${id}`]);
+        return gitLocal(wt, ['rev-parse', 'HEAD']).trim();
+    }
+    function declareCohort(refs) {
+        (0, store_1.initJournal)(planRoot, BRANCH);
+        const s0 = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        s0.cohortPhase = 'JOINING';
+        s0.cohortBaseSha = baseSha;
+        s0.tracks = refs;
+        (0, store_1.writeJournal)(planRoot, BRANCH, s0);
+        return (0, store_1.readJournal)(planRoot, BRANCH).state;
+    }
+    async function driveToConvergence(runtime, maxTicks = 20) {
+        let s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        for (let i = 0; i < maxTicks; i++) {
+            if (s.tracks.every((t) => t.phase === 'MERGED_UNVERIFIED'))
+                break;
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        return s;
+    }
+    // --- Los 5 puntos de crash "en línea recta" (sin conflicto real): -------
+    // 'after-merge-effect' y 'after-merge-observation' colapsan a la MISMA
+    // frontera observable en esta implementación síncrona (`runMergeTrack`
+    // lee-decide-ejecuta-relee-persiste dentro de UNA sola invocación, sin
+    // punto async intermedio entre "el merge real ya ocurrió" y "se
+    // observó/persistió") — mismo criterio que `track-bootstrap-crash.test.ts`
+    // documenta para sus propios puntos no alcanzables como boundary externo
+    // (`after-prepare-intent`/`after-worktree-effect`). Ambos se prueban acá
+    // con la MISMA construcción manual: el merge real ya corrió (vía
+    // `mergeFrozenTrack` invocado directamente, fuera de `reconcileTracks`,
+    // igual que `buildRuntime` de Task 9 llama a `defaultTrackRuntime(...)
+    // .addWorktree(...)` a mano) pero el journal todavía muestra `JOIN_INTENT`.
+    const crashPoints = [
+        'after-join-request', 'after-join-intent', 'after-merge-effect', 'after-merge-observation', 'after-merged-result',
+    ];
+    test.each(crashPoints)('join converge desde %s sin doble merge (R6.2, R6.8)', async (point) => {
+        const aHead = makeTrackHead('a', 'a.txt', 'A content\n');
+        const bHead = makeTrackHead('b', 'b.txt', 'B content\n');
+        const refA = trackRef('a', { frozenHeadSha: aHead });
+        const refB = trackRef('b', { frozenHeadSha: bHead });
+        const intentA = { expectedPlanHeadSha: baseSha, expectedTrackHeadSha: aHead, strategy: 'no-ff' };
+        if (point === 'after-join-request') {
+            declareCohort([refA, refB]);
+        }
+        else if (point === 'after-join-intent') {
+            declareCohort([{ ...refA, phase: 'JOIN_INTENT', joinIntent: intentA }, refB]);
+        }
+        else if (point === 'after-merge-effect' || point === 'after-merge-observation') {
+            declareCohort([{ ...refA, phase: 'JOIN_INTENT', joinIntent: intentA }, refB]);
+            // El merge real YA corrió (crash entre el efecto git y su
+            // observación/persistencia) — reproducido a mano con la MISMA
+            // función real que usaría `runMergeTrack`.
+            (0, git_1.mergeFrozenTrack)(planRoot, intentA);
+        }
+        else {
+            // 'after-merged-result': A ya quedó completamente persistido como
+            // MERGED_UNVERIFIED en un ciclo anterior — el merge real también
+            // ya corrió.
+            (0, git_1.mergeFrozenTrack)(planRoot, intentA);
+            const mergedHead = gitLocal(planRoot, ['rev-parse', 'HEAD']).trim();
+            const s0 = declareCohort([
+                { ...refA, phase: 'MERGED_UNVERIFIED', joinIntent: intentA, joinedCommitSha: mergedHead },
+                refB,
+            ]);
+            s0.cohortPlanHeadSha = mergedHead;
+            (0, store_1.writeJournal)(planRoot, BRANCH, s0);
+        }
+        const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+        const finalState = await driveToConvergence(runtime);
+        // C11-adjacent: ni un merge de más por track, sin importar desde qué
+        // frontera arrancó el "restart".
+        expect(mergeCommitCountFor(planRoot, aHead)).toBe(1);
+        expect(mergeCommitCountFor(planRoot, bHead)).toBe(1);
+        expect((0, git_1.readMergeHead)(planRoot)).toBeNull();
+        expect((0, git_1.dirtyPaths)(planRoot)).toEqual([]);
+        const a = finalState.tracks.find((t) => t.trackId === 'a');
+        const b = finalState.tracks.find((t) => t.trackId === 'b');
+        expect(a.phase).toBe('MERGED_UNVERIFIED');
+        expect(b.phase).toBe('MERGED_UNVERIFIED');
+        // C7: `integration.lock` adquirido antes del primer join y RETENIDO
+        // (Task 12 lo libera recién tras el interlock final — esta task
+        // nunca lo suelta).
+        expect(fs_1.default.existsSync((0, paths_1.integrationLockPath)(planRoot))).toBe(true);
+    });
+    // --- 'during-conflict': fixture con conflicto REAL (misma línea en el
+    // merge de A ya aplicado y en el frozenHeadSha de B), no incluido en la
+    // tabla de arriba porque su convergencia NO es "ambos MERGED_UNVERIFIED"
+    // — es "el merge propio se abortó y queda reintentable, con índice
+    // limpio" (texto explícito del plan). -----------------------------------
+    test('join converge desde during-conflict abortando solo el merge propio, con índice limpio (R6.2, R6.8)', async () => {
+        // A y B editan la MISMA línea de `shared.txt`: al mergear A primero
+        // (limpio, contra `baseSha`) y a B después (contra el merge de A),
+        // git produce un conflicto REAL de contenido — no una carrera de
+        // HEAD ni un `assertPlanHead` fallido.
+        const aHead = makeTrackHead('a', 'shared.txt', 'A-version\n');
+        const bHead = makeTrackHead('b', 'shared.txt', 'B-version\n');
+        const refA = trackRef('a', { frozenHeadSha: aHead });
+        const refB = trackRef('b', { frozenHeadSha: bHead });
+        declareCohort([refA, refB]);
+        const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+        // Fase 1: converger A por el camino normal (limpio) hasta que quede
+        // MERGED_UNVERIFIED y B tenga su propio JOIN_INTENT persistido —
+        // ambos pasos vía el driver real, sin inyectar nada todavía.
+        let s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        for (let i = 0; i < 20; i++) {
+            const a = s.tracks.find((t) => t.trackId === 'a');
+            const b = s.tracks.find((t) => t.trackId === 'b');
+            if (a.phase === 'MERGED_UNVERIFIED' && b.phase === 'JOIN_INTENT' && b.joinIntent !== undefined)
+                break;
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        const aAfter = s.tracks.find((t) => t.trackId === 'a');
+        const bAfter = s.tracks.find((t) => t.trackId === 'b');
+        expect(aAfter.phase).toBe('MERGED_UNVERIFIED');
+        expect(bAfter.phase).toBe('JOIN_INTENT');
+        const intentB = bAfter.joinIntent;
+        // --- Simular el crash: el merge de B YA se intentó de verdad (fuera
+        // de `reconcileTracks`, misma técnica que los otros puntos) y
+        // produjo un conflicto REAL — el proceso murió antes de observarlo.
+        expect(() => (0, git_1.mergeFrozenTrack)(planRoot, intentB)).toThrow();
+        expect((0, git_1.readMergeHead)(planRoot)).toBe(bHead);
+        expect((0, git_1.dirtyPaths)(planRoot).length).toBeGreaterThan(0);
+        // --- "Restart": UN tick real debe abortar el merge propio (mergeHead
+        // coincide con nuestro propio `expectedTrackHeadSha`) y dejar el
+        // índice limpio — B queda reintentable (JOIN_INTENT), NUNCA se marca
+        // MERGED_UNVERIFIED con un conflicto sin resolver.
+        const afterAbort = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        expect((0, git_1.readMergeHead)(planRoot)).toBeNull();
+        expect((0, git_1.dirtyPaths)(planRoot)).toEqual([]);
+        const bFinal = afterAbort.tracks.find((t) => t.trackId === 'b');
+        expect(['JOIN_INTENT', 'BLOCKED']).toContain(bFinal.phase);
+        expect(mergeCommitCountFor(planRoot, bHead)).toBe(0); // jamás se aplicó
+        expect(mergeCommitCountFor(planRoot, aHead)).toBe(1); // A no se re-tocó
+        // Un segundo ciclo completo (reintento -> conflicto de nuevo -> abort
+        // de nuevo) tampoco corrompe nada ni duplica el merge de A: la
+        // convergencia real de B requeriría resolución humana del conflicto,
+        // pero el mecanismo nunca dobla-mergea ni deja basura.
+        const afterRetryConflict = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, afterAbort, runtime, 2)).state;
+        const afterSecondAbort = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, afterRetryConflict, runtime, 2)).state;
+        expect((0, git_1.readMergeHead)(planRoot)).toBeNull();
+        expect((0, git_1.dirtyPaths)(planRoot)).toEqual([]);
+        expect(mergeCommitCountFor(planRoot, bHead)).toBe(0);
+        expect(mergeCommitCountFor(planRoot, aHead)).toBe(1);
+        const bSecond = afterSecondAbort.tracks.find((t) => t.trackId === 'b');
+        expect(['JOIN_INTENT', 'BLOCKED']).toContain(bSecond.phase);
+    });
+    // --- Post-review fix (Finding 1, revisión de Task 11): `ensureIntegrationLock`
+    // y el intento de merge/abort son DOS fronteras `reconcileTracks()`
+    // distintas — antes, un `ensureIntegrationLock` que hacía trabajo real
+    // (primer tick de un proceso vivo) seguía, en el MISMO call, a intentar
+    // el merge/abort (dos mutaciones reales en una sola invocación). Estos
+    // tests usan un `TrackRuntime` fake para `ensureIntegrationLock`
+    // (controlando directamente 'acquired'/'already-held') pero delegan
+    // `mergeFrozenTrack`/`abortOwnedMerge` al `defaultTrackRuntime` REAL —
+    // mismo criterio de mezcla real/fake que `buildRuntime` en
+    // `track-bootstrap-crash.test.ts`. No se reimplementa la reclamación de
+    // identidad muerta acá (eso ya lo prueba `join.test.ts`/Task 10 en
+    // aislamiento, con `ProcessRef`s fabricados) — lo que se prueba es la
+    // consecuencia en `runMergeTrack`: NUNCA fundir "lock recién adquirido"
+    // con "intento de merge" en un mismo call, sin importar cuántas veces un
+    // restart real haya tenido que re-adquirir de verdad.
+    describe('runMergeTrack — adquisición del lock y merge son fronteras separadas (Finding 1)', () => {
+        function fakeMergeRuntime(lockResult, calls) {
+            const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+            const unexpected = (what) => () => {
+                throw new Error(`no debería llamarse: ${what} (fixture ya en JOIN_INTENT, solo merge-track en juego)`);
+            };
+            return {
+                addWorktree: unexpected('addWorktree'),
+                initTrackJournal: unexpected('initTrackJournal'),
+                spawnSupervisor: unexpected('spawnSupervisor'),
+                observeSupervisor: unexpected('observeSupervisor'),
+                stopOwnSupervisor: async () => unexpected('stopOwnSupervisor')(),
+                removeOwnedWorktree: unexpected('removeOwnedWorktree'),
+                removeOwnedBranch: unexpected('removeOwnedBranch'),
+                emitFreezeRequest: unexpected('emitFreezeRequest'),
+                mergeFrozenTrack(repo, intent) {
+                    calls.merge.push(intent.expectedTrackHeadSha);
+                    real.mergeFrozenTrack(repo, intent);
+                },
+                abortOwnedMerge(repo, intent) {
+                    calls.abort.push(intent.expectedTrackHeadSha);
+                    real.abortOwnedMerge(repo, intent);
+                },
+                async ensureIntegrationLock() {
+                    calls.lock += 1;
+                    return lockResult;
+                },
+                pauseControllerGeneration: async () => unexpected('pauseControllerGeneration')(),
+                releaseIntegrationLockIfHeld: unexpected('releaseIntegrationLockIfHeld'),
+            };
+        }
+        function declareJoinIntentCohort(aHead, bHead) {
+            const refA = trackRef('a', { frozenHeadSha: aHead });
+            const refB = trackRef('b', { frozenHeadSha: bHead });
+            const intentA = { expectedPlanHeadSha: baseSha, expectedTrackHeadSha: aHead, strategy: 'no-ff' };
+            const s0 = declareCohort([{ ...refA, phase: 'JOIN_INTENT', joinIntent: intentA }, refB]);
+            return { s0, intentA };
+        }
+        test('un call que adquiere el lock por primera vez NO intenta el merge en ese mismo call (R6.2/C7)', async () => {
+            const aHead = makeTrackHead('a', 'a.txt', 'A content\n');
+            const bHead = makeTrackHead('b', 'b.txt', 'B content\n');
+            const { s0 } = declareJoinIntentCohort(aHead, bHead);
+            const calls = { lock: 0, merge: [], abort: [] };
+            const runtime = fakeMergeRuntime('acquired', calls);
+            const result = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s0, runtime, 2);
+            expect(calls.lock).toBe(1);
+            expect(calls.merge).toEqual([]);
+            expect(calls.abort).toEqual([]);
+            expect((0, git_1.readMergeHead)(planRoot)).toBeNull();
+            expect(mergeCommitCountFor(planRoot, aHead)).toBe(0);
+            const a = result.state.tracks.find((t) => t.trackId === 'a');
+            expect(a.phase).toBe('JOIN_INTENT'); // sin cambios: el intento de merge queda para el PRÓXIMO call
+        });
+        test('una vez el lock está confirmado held ("already-held"), el PRÓXIMO call sí intenta el merge (R6.2/C7)', async () => {
+            const aHead = makeTrackHead('a', 'a.txt', 'A content\n');
+            const bHead = makeTrackHead('b', 'b.txt', 'B content\n');
+            const { s0 } = declareJoinIntentCohort(aHead, bHead);
+            const calls = { lock: 0, merge: [], abort: [] };
+            const runtime = fakeMergeRuntime('already-held', calls);
+            const result = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s0, runtime, 2);
+            expect(calls.lock).toBe(1);
+            expect(calls.merge).toEqual([aHead]);
+            const a = result.state.tracks.find((t) => t.trackId === 'a');
+            expect(a.phase).toBe('MERGED_UNVERIFIED');
+        });
+        test('crash justo tras adquirir el lock + restart: el proceso nuevo tampoco funde adquisición y merge, y converge sin re-adquirir de más una vez confirmado held (Finding 1)', async () => {
+            const aHead = makeTrackHead('a', 'a.txt', 'A content\n');
+            const bHead = makeTrackHead('b', 'b.txt', 'B content\n');
+            const { s0 } = declareJoinIntentCohort(aHead, bHead);
+            let s = s0;
+            // "Proceso 1" (antes del crash): primer tick de un proceso vivo —
+            // `ensureIntegrationLock` hace trabajo real y devuelve 'acquired'.
+            // El "crash" ocurre justo acá: cero merges intentados todavía.
+            const callsP1 = { lock: 0, merge: [], abort: [] };
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, fakeMergeRuntime('acquired', callsP1), 2)).state;
+            expect(callsP1.merge).toEqual([]);
+            expect(s.tracks.find((t) => t.trackId === 'a').phase).toBe('JOIN_INTENT');
+            // "Proceso 2" (restart): closure de runtime NUEVA — el journal
+            // sigue mostrando JOIN_INTENT (nada se persiste sobre el lock en
+            // sí, por diseño: es un primitivo de filesystem ajeno al
+            // journal). Su PROPIO primer tick también adquiere de verdad
+            // (reclamo de identidad muerta del proceso 1 — esa lógica en
+            // aislamiento ya la prueba `join.test.ts`/Task 10) y por eso
+            // TAMBIÉN corta acá — nunca funde su propia adquisición con un
+            // intento de merge en el mismo call.
+            const callsP2a = { lock: 0, merge: [], abort: [] };
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, fakeMergeRuntime('acquired', callsP2a), 2)).state;
+            expect(callsP2a.merge).toEqual([]);
+            expect((0, git_1.readMergeHead)(planRoot)).toBeNull();
+            expect(mergeCommitCountFor(planRoot, aHead)).toBe(0);
+            expect(s.tracks.find((t) => t.trackId === 'a').phase).toBe('JOIN_INTENT');
+            // Recién ahora, con el lock confirmado held DENTRO del proceso 2
+            // (misma memoización por closure que la implementación real), el
+            // SIGUIENTE call avanza al intento de merge — una única vez, sin
+            // re-adquirir ni doble-adquirir.
+            const callsP2b = { lock: 0, merge: [], abort: [] };
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, fakeMergeRuntime('already-held', callsP2b), 2)).state;
+            expect(callsP2b.lock).toBe(1);
+            expect(callsP2b.merge).toEqual([aHead]);
+            expect(mergeCommitCountFor(planRoot, aHead)).toBe(1);
+            expect(s.tracks.find((t) => t.trackId === 'a').phase).toBe('MERGED_UNVERIFIED');
+        });
+    });
+    // --- Post-review fix (Finding 2, revisión de Task 11): el mensaje de una
+    // excepción capturada de `mergeFrozenTrack`/`abortOwnedMerge` JAMÁS decide
+    // nada (la relectura vía `gatherJoinObservation` sigue siendo la única
+    // fuente de verdad, R6.8) — pero ahora SÍ queda como `detail` diagnóstico
+    // en el evento correspondiente, para que un operador pueda distinguir un
+    // conflicto benigno de un repo estructuralmente roto.
+    describe('runMergeTrack — el mensaje de una excepción capturada queda como detail diagnóstico, nunca decide (Finding 2)', () => {
+        function readEvents() {
+            let raw = '';
+            try {
+                raw = fs_1.default.readFileSync((0, paths_1.eventsPath)(planRoot, BRANCH), 'utf8');
+            }
+            catch {
+                return [];
+            }
+            return raw.split('\n').filter((l) => l.trim().length > 0).map((l) => JSON.parse(l));
+        }
+        function runtimeWithThrowingMerge(errorMessage) {
+            const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+            return {
+                addWorktree: real.addWorktree, initTrackJournal: real.initTrackJournal,
+                spawnSupervisor: real.spawnSupervisor, observeSupervisor: real.observeSupervisor,
+                stopOwnSupervisor: real.stopOwnSupervisor, removeOwnedWorktree: real.removeOwnedWorktree,
+                removeOwnedBranch: real.removeOwnedBranch, emitFreezeRequest: real.emitFreezeRequest,
+                // Deliberadamente NUNCA llama a `real.mergeFrozenTrack`: el repo
+                // real queda intacto, así la relectura post-catch ve EXACTAMENTE
+                // lo mismo que `before` — la única forma honesta de probar que
+                // el mensaje de la excepción no cambia la decisión.
+                mergeFrozenTrack() { throw new Error(errorMessage); },
+                abortOwnedMerge() { throw new Error(errorMessage); },
+                async ensureIntegrationLock() { return 'already-held'; },
+                async pauseControllerGeneration() { return false; },
+                releaseIntegrationLockIfHeld() { },
+            };
+        }
+        test('retry-merge: fallo simulado ("disco lleno") queda como detail en track-merge-attempted, decisión sigue siendo retry (R6.8)', async () => {
+            const aHead = makeTrackHead('a', 'a.txt', 'A content\n');
+            const bHead = makeTrackHead('b', 'b.txt', 'B content\n');
+            const refA = trackRef('a', { frozenHeadSha: aHead });
+            const refB = trackRef('b', { frozenHeadSha: bHead });
+            const intentA = { expectedPlanHeadSha: baseSha, expectedTrackHeadSha: aHead, strategy: 'no-ff' };
+            const s0 = declareCohort([{ ...refA, phase: 'JOIN_INTENT', joinIntent: intentA }, refB]);
+            const runtime = runtimeWithThrowingMerge('fallo simulado: disco lleno');
+            const result = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s0, runtime, 2);
+            // Fail-safe: NUNCA se marca fundido por confiar en la excepción —
+            // el repo real nunca se tocó, así que la relectura post-catch
+            // sigue viendo "no fundido todavía" y el track queda reintentable.
+            expect(result.state.tracks.find((t) => t.trackId === 'a').phase).toBe('JOIN_INTENT');
+            expect(mergeCommitCountFor(planRoot, aHead)).toBe(0);
+            // Fail-LOUD: el mensaje SÍ quedó como rastro diagnóstico del evento.
+            const attempted = readEvents().filter((e) => e.kind === 'track-merge-attempted');
+            expect(attempted).toHaveLength(1);
+            expect(attempted[0].detail).toBe('fallo simulado: disco lleno');
+        });
+        test('abort-own-merge: fallo simulado queda como detail en track-merge-aborted, decisión sigue siendo abort-own-merge (R6.8)', async () => {
+            // Conflicto REAL (misma técnica que 'during-conflict' arriba):
+            // necesitamos un MERGE_HEAD real apuntando a nuestro propio
+            // `expectedTrackHeadSha` para que `decideJoinReconciliation`
+            // devuelva 'abort-own-merge'.
+            const aHead = makeTrackHead('a', 'shared.txt', 'A-version\n');
+            const bHead = makeTrackHead('b', 'shared.txt', 'B-version\n');
+            const refA = trackRef('a', { frozenHeadSha: aHead });
+            const refB = trackRef('b', { frozenHeadSha: bHead });
+            declareCohort([refA, refB]);
+            const realRuntime = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+            let s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+            for (let i = 0; i < 20; i++) {
+                const a = s.tracks.find((t) => t.trackId === 'a');
+                const b = s.tracks.find((t) => t.trackId === 'b');
+                if (a.phase === 'MERGED_UNVERIFIED' && b.phase === 'JOIN_INTENT' && b.joinIntent !== undefined)
+                    break;
+                s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, realRuntime, 2)).state;
+            }
+            const intentB = s.tracks.find((t) => t.trackId === 'b').joinIntent;
+            expect(() => (0, git_1.mergeFrozenTrack)(planRoot, intentB)).toThrow();
+            expect((0, git_1.readMergeHead)(planRoot)).toBe(bHead);
+            const runtime = runtimeWithThrowingMerge('fallo simulado: git binario roto');
+            const afterAbortAttempt = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+            // Fail-safe: el fake NUNCA corrió `git merge --abort` de verdad
+            // (el MERGE_HEAD sigue siendo nuestro), así que la relectura
+            // post-catch decide 'abort-own-merge' de nuevo — el track sigue
+            // en JOIN_INTENT, jamás se asume abortado por la excepción sola.
+            expect((0, git_1.readMergeHead)(planRoot)).toBe(bHead);
+            expect(afterAbortAttempt.tracks.find((t) => t.trackId === 'b').phase).toBe('JOIN_INTENT');
+            // Fail-LOUD: el mensaje quedó como detail diagnóstico.
+            const aborted = readEvents().filter((e) => e.kind === 'track-merge-aborted');
+            expect(aborted).toHaveLength(1);
+            expect(aborted[0].detail).toBe('fallo simulado: git binario roto');
+            // Limpieza real: el índice sigue con el conflicto real dejado por
+            // el `mergeFrozenTrack` de arriba — un abort real (fuera del
+            // driver, mismo patrón que el resto de este archivo) lo deja
+            // limpio para no ensuciar los tests siguientes.
+            (0, child_process_1.execFileSync)('git', ['merge', '--abort'], { cwd: planRoot, stdio: 'pipe' });
+        });
+    });
+});

package/dist/tests/commands/watch/track-runtime-git.test.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Task 8 post-review items 1 (CRITICAL) + 4: cobertura con git REAL de
+// `defaultTrackRuntime` — la única implementación que toca git/worktrees/
+// gitignore de verdad. Todos los demás tests de `reconcileTracks` usan un
+// `TrackRuntime` fake; este archivo es el que habría atrapado el bug crítico
+// original (chequear `.gitignore` contra el HEAD vivo del plan en vez de
+// contra el worktree recién creado, checkeado en `baseSha`).
+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 git_fixture_1 = require("../../helpers/git-fixture");
+const tracks_1 = require("../../../src/commands/watch/tracks");
+const git_1 = require("../../../src/core/tracks/git");
+function trackRef(worktreePath, overrides = {}) {
+    return {
+        trackId: 'x', worktreePath, branch: 'awm-track/x',
+        ownership: [], sharedResources: [], dependsOn: [],
+        fencingToken: 'f'.repeat(32), phase: 'PREPARE_INTENT', readinessNonce: 'r'.repeat(32),
+        ...overrides,
+    };
+}
+describe('defaultTrackRuntime — integración con git real (R4.1, R4.6, C2, post-review CRITICAL fix)', () => {
+    let planRoot;
+    let worktreePath;
+    beforeEach(() => {
+        planRoot = (0, git_fixture_1.initRepo)();
+        // `git worktree add` exige un destino que no exista o esté vacío: se
+        // reserva el nombre con mkdtemp y se libera antes de usarlo, para que
+        // el path sea único pero no un directorio ya ocupado por mkdtemp.
+        worktreePath = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-track-runtime-wt-'));
+        fs_1.default.rmdirSync(worktreePath);
+    });
+    afterEach(() => {
+        try {
+            (0, child_process_1.execFileSync)('git', ['worktree', 'prune'], { cwd: planRoot, stdio: 'pipe' });
+        }
+        catch { /* planRoot puede ya no ser un repo válido */ }
+        fs_1.default.rmSync(planRoot, { recursive: true, force: true });
+        fs_1.default.rmSync(worktreePath, { recursive: true, force: true });
+    });
+    test('happy path: crea el worktree real cuando `.awm` ya está ignorado en baseSha', () => {
+        (0, git_fixture_1.commitFile)(planRoot, '.gitignore', '.awm/\n');
+        const baseSha = (0, git_fixture_1.commitFile)(planRoot, 'a.txt', 'contenido'); // baseSha SÍ incluye el .gitignore commiteado arriba
+        const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, 'main');
+        const ref = trackRef(worktreePath);
+        expect(() => runtime.addWorktree(planRoot, ref, baseSha)).not.toThrow();
+        expect(fs_1.default.existsSync(path_1.default.join(worktreePath, 'a.txt'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(worktreePath, '.gitignore'))).toBe(true);
+        // `toContain` sobre la salida cruda compara STRINGS: git imprime separadores POSIX y
+        // el nombre largo, mientras `worktreePath` viene del tmpdir en 8.3 con backslashes.
+        // Se afirma la propiedad real — git registra ESTE worktree en ESTA branch — con la
+        // misma función que usa el producto.
+        expect((0, git_1.ownedWorktreeExists)(planRoot, worktreePath, 'awm-track/x')).toBe(true);
+    });
+    test('CRITICAL fix: baseSha SIN .gitignore de .awm pero el HEAD vivo del plan SÍ lo tiene — la comprobación vieja (contra planRoot) mentía "ignorado"; la nueva (contra el worktree) detecta que NO lo está y limpia el worktree que acaba de crear (C2)', () => {
+        // baseSha = el commit ANTES de que el plan declare `.awm/` ignorado.
+        const baseSha = (0, git_fixture_1.commitFile)(planRoot, 'a.txt', 'contenido');
+        // El HEAD VIVO del plan avanza y agrega el .gitignore DESPUÉS de baseSha.
+        (0, git_fixture_1.commitFile)(planRoot, '.gitignore', '.awm/\n');
+        // Demuestra la premisa exacta del bug: preguntarle al repo del plan en
+        // su HEAD vivo dice "ignorado" — pero el worktree que se va a crear
+        // está checkeado en `baseSha`, que NO tiene ese `.gitignore`.
+        expect((0, git_1.isAwmGitignored)(planRoot)).toBe(true);
+        const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, 'main');
+        const ref = trackRef(worktreePath);
+        expect(() => runtime.addWorktree(planRoot, ref, baseSha)).toThrow(/no está gitignoreado/);
+        // C2: el worktree es NUESTRO (lo acabamos de crear en esta misma
+        // llamada) — se descarta, nunca queda vivo e inseguro.
+        expect(fs_1.default.existsSync(worktreePath)).toBe(false);
+        const list = (0, child_process_1.execFileSync)('git', ['worktree', 'list'], { cwd: planRoot, encoding: 'utf8' });
+        expect(list).not.toContain(worktreePath);
+        // Prueba directa de que el worktree recién creado (checkeado en
+        // baseSha) efectivamente NO tenía el .gitignore, confirmando que la
+        // única forma honesta de responder es mirar el worktree, no el plan.
+        const probe = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-track-runtime-probe-'));
+        fs_1.default.rmdirSync(probe);
+        try {
+            (0, child_process_1.execFileSync)('git', ['worktree', 'add', probe, baseSha], { cwd: planRoot, stdio: 'pipe' });
+            expect((0, git_1.isAwmGitignored)(probe)).toBe(false);
+        }
+        finally {
+            try {
+                (0, child_process_1.execFileSync)('git', ['worktree', 'remove', '--force', probe], { cwd: planRoot, stdio: 'pipe' });
+            }
+            catch { /* best-effort */ }
+            fs_1.default.rmSync(probe, { recursive: true, force: true });
+        }
+    });
+    test('destino no vacío nunca se adopta (R4.6): addOwnedWorktree real rechaza sin siquiera llegar al chequeo de gitignore', () => {
+        const baseSha = (0, git_fixture_1.commitFile)(planRoot, 'a.txt', 'contenido');
+        fs_1.default.mkdirSync(worktreePath, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(worktreePath, 'foreign.txt'), 'ajeno');
+        const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, 'main');
+        const ref = trackRef(worktreePath);
+        expect(() => runtime.addWorktree(planRoot, ref, baseSha)).toThrow(/no vacío/);
+        expect(fs_1.default.existsSync(path_1.default.join(worktreePath, 'foreign.txt'))).toBe(true); // nunca tocado
+        const list = (0, child_process_1.execFileSync)('git', ['worktree', 'list'], { cwd: planRoot, encoding: 'utf8' });
+        expect(list).not.toContain(worktreePath);
+    });
+    test('initTrackJournal real: crea journal + descriptor en el worktree, y jamás pisa un trackContext ajeno preexistente (R4.6)', () => {
+        (0, git_fixture_1.commitFile)(planRoot, '.gitignore', '.awm/\n');
+        const baseSha = (0, git_fixture_1.commitFile)(planRoot, 'a.txt', 'contenido');
+        const runtime = (0, tracks_1.defaultTrackRuntime)(planRoot, 'main');
+        const ref = trackRef(worktreePath, { branch: 'awm-track/x' });
+        runtime.addWorktree(planRoot, ref, baseSha);
+        const context = { trackId: 'x', taskIds: [], planDigest: '', baseSha, planJournalId: 'j-plan-1' };
+        expect(() => runtime.initTrackJournal(ref, context)).not.toThrow();
+        expect(fs_1.default.existsSync(path_1.default.join(worktreePath, '.awm', 'track.json'))).toBe(true);
+        // Un trackContext AJENO preexistente (otro trackId) nunca se sobreescribe.
+        const foreignRef = trackRef(worktreePath, { trackId: 'y', branch: 'awm-track/x' });
+        const foreignContext = { trackId: 'y', taskIds: [], planDigest: '', baseSha, planJournalId: 'j-plan-1' };
+        expect(() => runtime.initTrackJournal(foreignRef, foreignContext)).toThrow(/pertenece a otro track/);
+    });
+});