agentic-workflow-manager 6.2.0 → 6.3.0

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

@@ -124,6 +124,28 @@ describe('runner concurrente', () => {
         expect(s.jobs['j1'].spawnNonce).toBe('nunca-claimeo');
         expect(calls).toEqual([{ id: 'j1', nonce: 'nunca-claimeo' }]);
     });
+    test('dispatch:false retiene el retry-same-intent de un intent YA vivo, solo bloquea el spawn de jobs `received` (regresión R6.3 — el freeze no debe deadlockear en spawn-intent)', () => {
+        // Job `received`: trabajo GENUINAMENTE nuevo — debe quedar frenado.
+        seedJob(repo, { id: 'fresh', executionState: 'received' });
+        // Job `spawn-intent` sin claim, fuera de gracia: intent YA decidido
+        // ANTES del freeze (ej. un wrapper que crasheo justo al pedirse) —
+        // `reconcileJobs` lo clasifica `never-started` => `retry-same-intent`.
+        // Eso es DRENAJE de trabajo en vuelo, no arranque de trabajo nuevo:
+        // debe seguir corriendo aunque `dispatch:false`.
+        seedJob(repo, {
+            id: 'stuck', executionState: 'spawn-intent', spawnNonce: 'stuck-nonce',
+            phaseTimestamps: { 'spawn-intent': new Date(Date.now() - 60000).toISOString() },
+        });
+        const retried = [];
+        const out = (0, runner_1.runnerTick)(repo, 'rama', (job) => { retried.push(job.id); }, { reconcileGraceMs: 1000, dispatch: false });
+        expect(out.decisions.find((d) => d.jobId === 'stuck' && d.action === 'retry-same-intent')).toBeDefined();
+        expect(retried).toEqual(['stuck']); // el retry del intent ya vivo SI corrio...
+        expect(out.spawned).toBe(0); // ...pero ningun job nuevo se despacho
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.jobs['fresh'].executionState).toBe('received'); // nunca avanzo a spawn-intent
+        expect(s.jobs['stuck'].executionState).toBe('spawn-intent'); // mismo intent, reintentado, no abandonado
+        expect(s.jobs['stuck'].spawnNonce).toBe('stuck-nonce');
+    });
     test('claim sin resultado con procesos muertos => orphaned, jamas relanzar (R1.8)', () => {
         const dead = { pid: 999999, startTime: 'gone', spawnNonce: 'nZ', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
         seedJob(repo, {

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

@@ -17,6 +17,7 @@ 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");
+const tracks_1 = require("../../../src/commands/watch/tracks");
 jest.setTimeout(60000);
 // runSupervisorLoop's full external-controller lifecycle (spawn stub codex ->
 // identity captured by the wrapper -> adopted via collectControllerGeneration's
@@ -62,6 +63,83 @@ async function until(fn, ms = 30000) {
         await new Promise((r) => setTimeout(r, 50));
     }
 }
+/** Mismo patron que `track-bootstrap-crash.test.ts::fakeProcessRef` — un
+ *  `ProcessRef` sintetico (nunca un proceso real) para trackear cuantas veces
+ *  se "spawneo" cada supervisor de track sin depender de wrappers reales. */
+function fakeProcessRef(trackId, n) {
+    return { pid: 1, startTime: `x-${n}`, spawnNonce: trackId, argvDigest: 'x', processGroup: 1, psArgsDigest: `x-${n}` };
+}
+/** Runtime para forzar un fallback-a-SERIAL REAL (Finding 2, ronda 2 de
+ *  re-review de Task 12): `addWorktree`/`teardownOwned` delegan al
+ *  `defaultTrackRuntime` de verdad (git real, mismo criterio que
+ *  `track-bootstrap-crash.test.ts::buildRuntime`) — solo `spawnSupervisor`/
+ *  `observeSupervisor` quedan fake, porque a esta prueba no le importa la
+ *  mecanica de un wrapper detached, sino que la cohorte atraviese el reducer
+ *  real (`nextProtocolEffect`/`reconcileTracks`) hasta `enter-serial`. El
+ *  worktree de `failWorktreeFor` falla SIEMPRE — el mismo disparador que usa
+ *  Task 9 para su `'fallo del segundo track limpia el primero antes de
+ *  serializar'`. */
+function buildFallbackRuntime(planRoot, wrapperState, spawnCalls, failWorktreeFor) {
+    const real = (0, tracks_1.defaultTrackRuntime)(planRoot, 'main');
+    return {
+        addWorktree(root, ref, baseSha) {
+            if (ref.trackId === failWorktreeFor)
+                throw new Error(`fallo inyectado: create-worktree de ${ref.trackId}`);
+            real.addWorktree(root, ref, baseSha);
+        },
+        initTrackJournal(ref, context) { real.initTrackJournal(ref, context); },
+        spawnSupervisor(ref) {
+            const n = (spawnCalls.get(ref.trackId) ?? 0) + 1;
+            spawnCalls.set(ref.trackId, n);
+            wrapperState.set(ref.trackId, 'claimed');
+            return fakeProcessRef(ref.trackId, n);
+        },
+        observeSupervisor(ref) {
+            const st = wrapperState.get(ref.trackId) ?? 'absent';
+            if (st === 'absent')
+                return { kind: 'absent' };
+            if (st === 'ready')
+                return { kind: 'ready', readinessNonce: ref.readinessNonce };
+            wrapperState.set(ref.trackId, 'ready');
+            return { kind: 'claimed' };
+        },
+        async stopOwnSupervisor() { return true; },
+        removeOwnedWorktree(repo, ref) { real.removeOwnedWorktree(repo, ref); },
+        removeOwnedBranch(repo, branch) { real.removeOwnedBranch(repo, branch); },
+        emitFreezeRequest() { throw new Error('no deberia llamarse (fallback a SERIAL nunca llega a freeze)'); },
+        mergeFrozenTrack() { throw new Error('no deberia llamarse (fallback a SERIAL nunca llega a merge)'); },
+        abortOwnedMerge() { throw new Error('no deberia llamarse (fallback a SERIAL nunca llega a merge)'); },
+        async ensureIntegrationLock() { throw new Error('no deberia llamarse (fallback a SERIAL nunca llega a integracion)'); },
+        async pauseControllerGeneration() { throw new Error('no deberia llamarse (fallback a SERIAL nunca llega a integracion)'); },
+        releaseIntegrationLockIfHeld() { throw new Error('no deberia llamarse (fallback a SERIAL nunca llega a integracion)'); },
+    };
+}
+/** Declara una cohorte de 2 tracks DIRECTAMENTE sobre el journal (mismo
+ *  criterio que `track-bootstrap-crash.test.ts::declareCohort`: esta es la
+ *  UNICA parte que no pasa por una request real — deliberado, porque
+ *  `track-prepare-request` (`apply.ts`) tambien registra cada
+ *  `track-integration:<trackId>` en el `cycleVerificationPlan` SIN
+ *  `satisfiedBy`, y nada limpia esos items cuando la cohorte cae a SERIAL
+ *  (el fallback nunca vuelve a satisfacerlos ni los remueve) — dejarian el
+ *  gate generico permanentemente rojo y esta prueba dejaria de probar lo que
+ *  el Finding 2 pide. Todo lo que pasa DESPUES de esta declaracion (worktree,
+ *  journal, teardown, `enter-serial`) SI atraviesa el reducer real via
+ *  `reconcileTracks`, exactamente como pide la ronda 2 de re-review. */
+function declareFallbackCohort(repo, tracksRoot, baseSha) {
+    const s0 = (0, store_1.readJournal)(repo, 'main').state;
+    s0.cohortPhase = 'PREPARING';
+    s0.cohortBaseSha = baseSha;
+    s0.tracks = ['a', 'b'].map((id) => ({
+        trackId: id,
+        worktreePath: path_1.default.join(tracksRoot, `track-${id}`),
+        branch: `awm-track/${id}`,
+        ownership: [], sharedResources: [], dependsOn: [],
+        fencingToken: `fence-${id}`.padEnd(32, '0'),
+        phase: 'DECLARED',
+        readinessNonce: `ready-${id}`.padEnd(32, '0'),
+    }));
+    (0, store_1.writeJournal)(repo, 'main', s0);
+}
 describe('supervisor loop', () => {
     let repo;
     let stubBin;
@@ -120,6 +198,78 @@ describe('supervisor loop', () => {
         expect(typeof final.cycle.completedAt).toBe('string');
         expect(Object.values(final.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass')).toBe(true);
     });
+    // Regresion (post-review #2, Task 12/R7 — Finding 2 de la segunda ronda
+    // de re-review): la version anterior de esta prueba armaba el escenario
+    // hand-mutando el journal directo a `cohortPhase = 'SERIAL'` con tracks
+    // REMOVED/DECLARED "a mano" — probaba la logica del GUARD en aislamiento,
+    // pero nunca demostraba que el guard se comporta bien contra un journal
+    // con la FORMA que un fallback real deja (teardown real, git real,
+    // secuencia exacta begin-teardown -> enter-serial que decide
+    // `protocol.ts`). Esta version dispara el MISMO fallback de Task 9
+    // (`track-bootstrap-crash.test.ts::'fallo del segundo track limpia el
+    // primero antes de serializar'`: track 'a' llega a ARMED con git real,
+    // 'b' falla su `create-worktree` real, `nextProtocolEffect` decide
+    // FALLBACK_PENDING -> begin-teardown de 'a' -> enter-serial) sobre el
+    // MISMO journal que despues se usa para el camino generico de
+    // finalizacion de ciclo (task done + qa/interlock satisfechos, cero jobs
+    // vivos) y confirma que `cycle.status` llega a COMPLETE por ese camino
+    // generico, exactamente como lo haria un plan sin tracks en absoluto.
+    test('una cohorte que cayo a fallback SERIAL via el reducer real no cuelga el ciclo: COMPLETE llega igual por el camino generico (regresion post-review R7, ronda 2)', async () => {
+        (0, init_1.initWatch)(repo, 'main');
+        const tracksRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-loop-tracks-'));
+        try {
+            const baseSha = (0, child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: repo, encoding: 'utf8' }).trim();
+            declareFallbackCohort(repo, tracksRoot, baseSha);
+            // --- Fase 1: conducir la cohorte REAL (protocolo + git real)
+            // hasta SERIAL, sin pasar por Supervisor.tick() todavia (misma
+            // tecnica que track-bootstrap-crash.test.ts).
+            const wrapperState = new Map();
+            const spawnCalls = new Map();
+            const fallbackRuntime = buildFallbackRuntime(repo, wrapperState, spawnCalls, 'b');
+            let s = (0, store_1.readJournal)(repo, 'main').state;
+            for (let i = 0; i < 200 && s.cohortPhase !== 'SERIAL'; i++) {
+                s = (await (0, tracks_1.reconcileTracks)(repo, 'main', s, fallbackRuntime, 2)).state;
+            }
+            expect(s.cohortPhase).toBe('SERIAL');
+            // Mismo shape que exige `assertProtocolInvariants` para SERIAL, y
+            // el mismo que deja el fallback real de Task 9: REMOVED/DECLARED,
+            // nunca inventado por el test.
+            for (const t of s.tracks)
+                expect(['REMOVED', 'DECLARED']).toContain(t.phase);
+            expect(s.tracks).toHaveLength(2); // el array nunca se vacia (la regresion original)
+            // --- Fase 2: sobre ESE MISMO journal, completar el ciclo por el
+            // camino generico (task done + qa/interlock satisfechos + cero
+            // jobs vivos) — la misma receta que la prueba R4.5 de arriba.
+            (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', 'process.exit(0)'], [], '.', { 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' } });
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 50, reconcileGraceMs: 10000 };
+            const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner);
+            let outcome = 'continue';
+            for (let i = 0; i < 400 && outcome !== 'complete'; i++) {
+                outcome = await sup.tick();
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            expect(outcome).toBe('complete');
+            const final = (0, store_1.readJournal)(repo, 'main').state;
+            expect(final.cycle.status).toBe('COMPLETE');
+            expect(final.cohortPhase).toBe('SERIAL'); // nunca inventa una transicion SERIAL -> COMPLETE
+            for (const t of final.tracks)
+                expect(['REMOVED', 'DECLARED']).toContain(t.phase);
+        }
+        finally {
+            fs_1.default.rmSync(tracksRoot, { recursive: true, force: 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;

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

@@ -0,0 +1,342 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Task 9 (R4.2, R4.3, R4.5, R4.6, R4.8, R4.9, R4.10, C1, C2, C11): crash/
+// restart de P1 (bootstrap de tracks) y fallback serial tras bootstrap
+// parcial. A diferencia de `track-bootstrap.test.ts` (Task 8, `TrackRuntime`
+// completamente fake), esta suite usa git REAL para `addWorktree`/
+// `initTrackJournal`/teardown de worktree+branch (`defaultTrackRuntime`,
+// mismo patrón que `track-runtime-git.test.ts`) — la única forma honesta de
+// probar C11 ("sin duplicar recursos") es mirar el repo real, no solo los
+// eventos. `spawnSupervisor`/`observeSupervisor` quedan fake (nada de
+// procesos reales): lo que importa acá es que `tracks.ts` nunca vuelva a
+// invocarlos de más tras un crash, no la mecánica real de un wrapper
+// detached (eso ya lo cubre `supervisor-wrapper.test.ts`).
+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 process_1 = require("../../../src/core/journal/process");
+const BRANCH = 'main';
+/** T13: a diferencia de un `pid`/`startTime` totalmente inventados (que
+ *  `refIsAlive` — identity-verified, R4.8 — correctamente reportaría como
+ *  "muerto", porque ningún proceso real matchea esos campos), esto captura la
+ *  identidad REAL del propio proceso de test (siempre vivo mientras corre la
+ *  suite), con un nonce distinto por (trackId, intento) — deja ejercitar de
+ *  verdad el camino `stop-own-supervisor` de `runBeginTeardown` (Task 13) sin
+ *  depender de un supervisor real. */
+function fakeProcessRef(trackId, n) {
+    return (0, process_1.captureSelfRef)(`${trackId}-${n}`);
+}
+/** Runtime combinado: `addWorktree`/`initTrackJournal`/teardown de worktree y
+ *  branch delegan al `defaultTrackRuntime` REAL (git de verdad) — el paso
+ *  `supervisor` del teardown y el spawn/observe del supervisor quedan fake,
+ *  respaldados por `instr` (que el test puede mutar directamente para
+ *  simular "esto ya pasó antes del crash"). */
+function buildRuntime(planRoot, instr, opts = {}) {
+    const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+    return {
+        addWorktree(root, ref, baseSha) {
+            if (ref.trackId === opts.failWorktreeFor)
+                throw new Error(`fallo inyectado: create-worktree de ${ref.trackId}`);
+            real.addWorktree(root, ref, baseSha);
+        },
+        initTrackJournal(ref, context) {
+            real.initTrackJournal(ref, context);
+        },
+        spawnSupervisor(ref) {
+            const n = (instr.spawnCalls.get(ref.trackId) ?? 0) + 1;
+            instr.spawnCalls.set(ref.trackId, n);
+            // El "wrapper" real, al arrancar, escribe su claim antes que nada
+            // (mismo contrato que `supervisor-wrapper.ts`): simulamos eso acá.
+            instr.wrapperState.set(ref.trackId, 'claimed');
+            return fakeProcessRef(ref.trackId, n);
+        },
+        observeSupervisor(ref) {
+            const st = instr.wrapperState.get(ref.trackId) ?? 'absent';
+            if (st === 'absent')
+                return { kind: 'absent' };
+            if (st === 'ready')
+                return { kind: 'ready', readinessNonce: ref.readinessNonce };
+            // 'claimed'/'identified' colapsan al mismo `SupervisorObservation`
+            // que produce el `observeSupervisorFromDisk` real cuando el claim
+            // ya existe pero `ready.json` todavía no (ver su código: ambos
+            // casos devuelven 'claimed') — la recuperación de Task 9 no
+            // necesita distinguirlos, solo saber que YA hay evidencia real.
+            // El wrapper real sigue vivo (es un proceso aparte, ajeno a que
+            // el supervisor del PLAN haya crasheado) y termina su propio
+            // bootstrap poco después: la SIGUIENTE observación ya lo ve listo.
+            instr.wrapperState.set(ref.trackId, 'ready');
+            return { kind: 'claimed' };
+        },
+        async stopOwnSupervisor(ref) {
+            instr.teardownEvents.push(`supervisor-stopped:${ref.trackId}`);
+            return true;
+        },
+        removeOwnedWorktree(repo, ref) {
+            real.removeOwnedWorktree(repo, ref);
+            instr.teardownEvents.push(`worktree-removed:${ref.trackId}`);
+        },
+        removeOwnedBranch(repo, branchName) {
+            real.removeOwnedBranch(repo, branchName);
+            // El fake no conoce el trackId acá (mismo dato que `git.ts` usa:
+            // solo el nombre de branch) — se reconstruye del nombre
+            // determinista `awm-track/<id>` para mantener el mismo formato
+            // de evento que el resto de esta suite.
+            const trackId = branchName.split('/').pop() ?? branchName;
+            instr.teardownEvents.push(`branch-removed:${trackId}`);
+        },
+        emitFreezeRequest() { throw new Error('no debería llamarse (Task 10, sin cobertura en esta suite)'); },
+        mergeFrozenTrack() { throw new Error('no debería llamarse (Task 11, sin cobertura en esta suite)'); },
+        abortOwnedMerge() { throw new Error('no debería llamarse (Task 11, sin cobertura en esta suite)'); },
+        async ensureIntegrationLock() { throw new Error('no debería llamarse (Task 11, sin cobertura en esta suite)'); },
+        async pauseControllerGeneration() { throw new Error('no debería llamarse (Task 12, sin cobertura en esta suite)'); },
+        releaseIntegrationLockIfHeld() { throw new Error('no debería llamarse (Task 12, sin cobertura en esta suite)'); },
+    };
+}
+function declareCohort(planRoot, root, baseSha, trackIds) {
+    (0, store_1.initJournal)(planRoot, BRANCH);
+    const s0 = (0, store_1.readJournal)(planRoot, BRANCH).state;
+    s0.cohortPhase = 'PREPARING';
+    s0.cohortBaseSha = baseSha;
+    s0.tracks = trackIds.map((id) => ({
+        trackId: id,
+        worktreePath: path_1.default.join(root, `track-${id}`),
+        branch: `awm-track/${id}`,
+        ownership: [], sharedResources: [], dependsOn: [],
+        fencingToken: `fence-${id}`.padEnd(32, '0'),
+        phase: 'DECLARED',
+        readinessNonce: `ready-${id}`.padEnd(32, '0'),
+    }));
+    (0, store_1.writeJournal)(planRoot, BRANCH, s0);
+    return (0, store_1.readJournal)(planRoot, BRANCH).state;
+}
+/** Fija la fase de `trackId` directamente en el journal persistido, SIN pasar
+ *  por `reconcileTracks` — necesario para 'after-prepare-intent' y
+ *  'after-worktree-effect': `persist-prepare-intent` es una transición
+ *  puramente en memoria que `reconcileTracks` drena en el MISMO call que ya
+ *  intenta `create-worktree` a continuación (ver el comentario grande sobre
+ *  `reconcileTracks` en `tracks.ts`), así que "recién persistido
+ *  PREPARE_INTENT, todavía nada más" no es un boundary EXTERNO alcanzable
+ *  con un tick — hay que construirlo a mano para representar fielmente ese
+ *  instante exacto de un crash real. */
+function setPhase(planRoot, branch, trackId, phase) {
+    const s = (0, store_1.readJournal)(planRoot, branch).state;
+    s.tracks = s.tracks.map((t) => (t.trackId === trackId ? { ...t, phase } : t));
+    (0, store_1.writeJournal)(planRoot, branch, s);
+    return (0, store_1.readJournal)(planRoot, branch).state;
+}
+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;
+}
+describe('reconcileTracks — crash/restart de P1 con git real (Task 9, R4.2/R4.3/R4.6/R4.8/R4.9/C1/C2/C11)', () => {
+    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-track-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 });
+    });
+    const crashPoints = [
+        'after-prepare-intent', 'after-worktree-effect', 'after-worktree-result',
+        'after-journal-effect', 'after-journal-result', 'after-supervisor-intent',
+        'after-supervisor-claim', 'after-supervisor-identity', 'after-readiness',
+    ];
+    test.each(crashPoints)('restart converge desde %s sin duplicar recursos (R4.2, C11)', async (point) => {
+        const instr = { spawnCalls: new Map(), wrapperState: new Map(), teardownEvents: [] };
+        const runtime = buildRuntime(planRoot, instr);
+        let s = declareCohort(planRoot, root, baseSha, ['a', 'b']);
+        // --- Fase 1: avanzar el track 'a' con ticks REALES hasta el punto
+        // natural más cercano al crash pedido (todo boundary que
+        // `reconcileTracks` ya persiste solo antes de tocar runtime de
+        // nuevo). 'b' se queda en DECLARED: PREPARING procesa un track a la
+        // vez, alfabéticamente, así que jamás arranca antes de que 'a' llegue
+        // a ARMED.
+        //
+        // 'after-prepare-intent'/'after-worktree-effect' son la EXCEPCIÓN:
+        // `persist-prepare-intent` es puramente en memoria y `reconcileTracks`
+        // la drena en el MISMO call que ya intenta `create-worktree` a
+        // continuación (ver el comentario grande sobre `reconcileTracks` en
+        // `tracks.ts`) — "recién PREPARE_INTENT, todavía nada más" no es un
+        // boundary externo alcanzable con un tick, así que se construye a
+        // mano con `setPhase` en vez de tickear.
+        const stopWhen = {
+            'after-worktree-result': (r) => r.phase === 'WORKTREE_CREATED',
+            'after-journal-effect': (r) => r.phase === 'WORKTREE_CREATED',
+            'after-journal-result': (r) => r.phase === 'JOURNAL_CREATED',
+            'after-supervisor-intent': (r) => r.phase === 'SUPERVISOR_STARTING' && r.supervisorIntent !== undefined,
+            'after-supervisor-claim': (r) => r.phase === 'SUPERVISOR_STARTING' && r.supervisorIntent !== undefined,
+            'after-supervisor-identity': (r) => r.phase === 'SUPERVISOR_STARTING' && r.supervisorIntent !== undefined,
+            'after-readiness': (r) => r.phase === 'ARMED',
+        };
+        if (point === 'after-prepare-intent' || point === 'after-worktree-effect') {
+            s = setPhase(planRoot, BRANCH, 'a', 'PREPARE_INTENT');
+        }
+        else {
+            for (let i = 0; i < 50; i++) {
+                const a = s.tracks.find((t) => t.trackId === 'a');
+                if (stopWhen[point](a))
+                    break;
+                s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+            }
+            const preCrashA = s.tracks.find((t) => t.trackId === 'a');
+            expect(stopWhen[point](preCrashA)).toBe(true);
+        }
+        // --- Simular el crash: para los 4 puntos donde el efecto real YA
+        // corrió pero `tracks.ts` no llegó a persistir la observación, se
+        // ejecuta la mutación real (mismas funciones que usaría
+        // `runCreateWorktree`/`runSpawnTrackSupervisor`) SIN pasar por
+        // `reconcileTracks` — así el journal queda exactamente como
+        // quedaría tras un crash real justo ahí.
+        const refA = () => s.tracks.find((t) => t.trackId === 'a');
+        if (point === 'after-worktree-effect') {
+            (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH).addWorktree(planRoot, refA(), baseSha);
+        }
+        if (point === 'after-journal-effect') {
+            (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH).initTrackJournal(refA(), {
+                trackId: 'a', taskIds: [], planDigest: '', baseSha, planJournalId: s.journalId,
+            });
+        }
+        if (point === 'after-supervisor-claim' || point === 'after-supervisor-identity') {
+            // El spawn real ya ocurrió (proceso detached lanzado) y el
+            // wrapper ya escribió su claim (y, en 'identity', también su
+            // identity sidecar) — pero el supervisor del PLAN crasheó antes
+            // de persistir `supervisorProcessRef`.
+            runtime.spawnSupervisor(refA());
+            instr.wrapperState.set('a', point === 'after-supervisor-claim' ? 'claimed' : 'identified');
+        }
+        // --- Fase 2 ("restart"): instrumentación fresca salvo lo que
+        // sobreviviría de verdad a un crash (spawnCalls y wrapperState ya
+        // acumulados arriba SÍ persisten — representan el mundo real, no
+        // memoria de proceso). Reconciliar hasta que la cohorte quede ACTIVE.
+        for (let i = 0; i < 100 && s.cohortPhase !== 'ACTIVE'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        expect(s.cohortPhase).toBe('ACTIVE');
+        for (const t of s.tracks)
+            expect(['ACTIVE', 'ARMED']).toContain(t.phase);
+        // C11: ni un spawn de más, ni un worktree de más, por track.
+        expect(Object.fromEntries(instr.spawnCalls)).toEqual({ a: 1, b: 1 });
+        const branches = realWorktreeBranches(planRoot);
+        expect(branches.filter((b) => b === 'awm-track/a')).toHaveLength(1);
+        expect(branches.filter((b) => b === 'awm-track/b')).toHaveLength(1);
+        // Ningún track quedó BLOCKED (el crash nunca debe leerse como ajeno).
+        for (const t of s.tracks)
+            expect(t.blockedReason).toBeUndefined();
+    });
+    // No entra en `crashPoints`/`test.each` de arriba a propósito: esa matriz
+    // asume que un restart converge SIN volver a llamar `spawnSupervisor`
+    // (`spawnCalls === {a:1, b:1}`). Esta ventana es la excepción real —
+    // documentada acá en vez de forzarla dentro de esa tabla compartida.
+    test('crash entre el fork real del wrapper y su claim en disco: el restart re-spawnea de más; la exclusión de un segundo proceso VIVO la garantiza supervisor-wrapper.ts, no este driver (R4.2, C11)', async () => {
+        // Ventana real que `observeSupervisor`/`decidePrepare` NO pueden
+        // cerrar: entre que `runtime.spawnSupervisor` forkea el proceso
+        // detached de verdad y que ESE proceso llega a
+        // `fs.openSync(claimPath, 'wx', ...)` (`supervisor-wrapper.ts`), no
+        // hay ningún artefacto en disco. Si el supervisor del PLAN crashea
+        // justo ahí, el restart observa 'absent' (lo único honesto: no hay
+        // evidencia todavía) y `decidePrepare` vuelve a pedir
+        // 'retry-supervisor-same-intent' — `spawnSupervisor` se llama DE
+        // NUEVO, un segundo fork real. Este test no simula al segundo
+        // wrapper perdiendo la carrera de `wx`/`EEXIST` contra el primero
+        // (el fake de este archivo no modela dos procesos wrapper
+        // concurrentes) — esa exclusión, la que de verdad evita terminar con
+        // dos supervisores VIVOS, ya tiene cobertura dedicada en
+        // `cli/tests/commands/track/supervisor-wrapper.test.ts` ("un segundo
+        // wrapper con el mismo claim detecta el claim existente y sale sin
+        // lanzar otro supervisor (C11)"). Lo que se prueba acá es que la
+        // segunda llamada a `spawnSupervisor` es el comportamiento ESPERADO
+        // en esta ventana, no una regresión de C11.
+        const instr = { spawnCalls: new Map(), wrapperState: new Map(), teardownEvents: [] };
+        const runtime = buildRuntime(planRoot, instr);
+        let s = declareCohort(planRoot, root, baseSha, ['a', 'b']);
+        for (let i = 0; i < 50; i++) {
+            const a = s.tracks.find((t) => t.trackId === 'a');
+            if (a.phase === 'SUPERVISOR_STARTING' && a.supervisorIntent !== undefined)
+                break;
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        const refA = () => s.tracks.find((t) => t.trackId === 'a');
+        expect(refA().phase).toBe('SUPERVISOR_STARTING');
+        expect(refA().supervisorProcessRef).toBeUndefined();
+        // Simular el fork real SIN claim en disco: a diferencia de
+        // 'after-supervisor-claim'/'after-supervisor-identity' (que llaman a
+        // `runtime.spawnSupervisor` y dejan que el fake avance
+        // `wrapperState`), acá solo se incrementa el contador de forks —
+        // `wrapperState` de 'a' queda 'absent' a propósito, representando la
+        // instantánea exacta ANTES de que el wrapper real escriba su claim.
+        instr.spawnCalls.set('a', 1);
+        for (let i = 0; i < 100 && s.cohortPhase !== 'ACTIVE'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        expect(s.cohortPhase).toBe('ACTIVE');
+        // El driver no tiene forma de saber que ya había un fork en vuelo:
+        // vuelve a spawnear. Dos llamadas reales a `spawnSupervisor` para
+        // 'a' es el resultado ESPERADO en esta ventana — no un bug de C11 —
+        // y por eso NO se afirma `spawnCalls === {a:1, b:1}` acá.
+        expect(instr.spawnCalls.get('a')).toBe(2);
+        expect(instr.spawnCalls.get('b')).toBe(1);
+    });
+    test('fallo del segundo track limpia el primero antes de serializar (R4.5, C2)', async () => {
+        const instr = { spawnCalls: new Map(), wrapperState: new Map(), teardownEvents: [] };
+        const runtime = buildRuntime(planRoot, instr, { failWorktreeFor: 'b' });
+        let s = declareCohort(planRoot, root, baseSha, ['a', 'b']);
+        for (let i = 0; i < 200 && s.cohortPhase !== 'SERIAL'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, runtime, 2)).state;
+        }
+        // Marcador propio del test (no de `runtime`): registra el momento en
+        // que la cohorte se observa por primera vez en SERIAL, para poder
+        // comparar su índice contra el de 'branch-removed:a' más abajo —
+        // `nextProtocolEffect` solo emite 'enter-serial' una vez que TODOS
+        // los tracks owned llegan a REMOVED (ver el branch `FALLBACK_PENDING`
+        // en `protocol.ts`), así que este push siempre queda estrictamente
+        // después de cualquier evento de teardown real.
+        instr.teardownEvents.push('serial-entered');
+        expect(s.cohortPhase).toBe('SERIAL');
+        for (const t of s.tracks)
+            expect(['REMOVED', 'DECLARED']).toContain(t.phase);
+        // 'a' (el sobreviviente hasta que 'b' falló) tuvo que desmantelarse
+        // de verdad: supervisor "detenido", worktree y branch reales
+        // removidos — en ese orden, y ANTES de entrar a SERIAL.
+        expect(instr.teardownEvents).toEqual(expect.arrayContaining([
+            'supervisor-stopped:a', 'worktree-removed:a', 'branch-removed:a',
+        ]));
+        expect(instr.teardownEvents.indexOf('branch-removed:a')).toBeLessThan(instr.teardownEvents.indexOf('serial-entered'));
+        // Prueba REAL (no solo eventos): ni worktree ni branch de 'a' siguen vivos.
+        const branches = realWorktreeBranches(planRoot);
+        expect(branches).not.toContain('awm-track/a');
+        expect(branches).not.toContain('awm-track/b');
+        const worktreeA = path_1.default.join(root, 'track-a');
+        expect(fs_1.default.existsSync(worktreeA)).toBe(false);
+        const list = (0, child_process_1.execFileSync)('git', ['branch', '--list'], { cwd: planRoot, encoding: 'utf8' });
+        expect(list).not.toContain('awm-track/a');
+        expect(list).not.toContain('awm-track/b');
+    });
+});