agentic-workflow-manager 9.6.1 → 9.7.0

package/README.md

@@ -69,6 +69,8 @@ and one JSON argv integration command. Start or resume with `awm watch`; inspect
 `awm track status`. Track workers commit only their assigned files and request
 `awm track join`. The plan supervisor freezes and merges tracks, runs global QA once on the
 final HEAD, executes the canonical integration job once, then applies the interlock.
+`awm track remove` requests a safe cancellation of the complete cohort; only demonstrably
+owned resources are removed before returning to serial execution.
 
 Any missing declaration, overlap, global file class, unavailable worktree, or failed
 preparation degrades to serial with an event naming the cause. `BLOCKED` means ownership or

package/dist/src/commands/track/index.js

@@ -104,14 +104,10 @@ function registerTrackCommand(program) {
         }
         process.stdout.write(JSON.stringify({ requestId: r.requestId, idempotencyKey: r.idempotencyKey, qaHeadSha: r.qaHeadSha }, null, 2) + '\n');
     });
-    // NO IMPLEMENTADO del lado del supervisor: no hay handler para `track-teardown-request`,
-    // así que la request se emite y el supervisor la RECHAZA (`request-rejected-invalid`).
-    // La descripción lo dice en vez de prometer un desmantelamiento que no ocurre — hasta
-    // este release afirmaba que el supervisor desmantelaba worktree/rama, y no lo hacía.
-    // El teardown que sí funciona es el automático de la degradación a serial
-    // (`begin-teardown` desde `FALLBACK_PENDING`), que no pasa por este verbo.
+    // Request-only: el supervisor persiste la intención, cancela la cohorte completa y
+    // reutiliza el teardown fail-closed antes de volver a ejecución serial.
     track.command('remove')
-        .description('NO IMPLEMENTADO: emite track-teardown-request, que el supervisor todavía no sabe aplicar y rechaza')
+        .description('emite track-teardown-request — cancela la cohorte y solicita teardown seguro antes del fallback serial')
         .requiredOption('--generation <token>', 'token de la generacion vigente')
         .argument('<trackId>')
         .action((trackId, opts) => {

package/dist/src/commands/watch/apply.js

@@ -250,6 +250,21 @@ function applyRequestToState(s, env, digest, repoRoot) {
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: trackId });
         return;
     }
+    if (env.kind === 'track-teardown-request') {
+        const p = env.payload;
+        if (typeof p.trackId !== 'string' || p.trackId.length === 0)
+            throw new Error('track-teardown-request requiere trackId');
+        const trackId = p.trackId;
+        const ref = s.tracks?.find((t) => t.trackId === trackId);
+        if (ref === undefined)
+            throw new Error(`track-teardown-request: track desconocido: ${trackId}`);
+        if (s.tracks === undefined || s.tracks.length < 2 || s.cohortPhase === undefined) {
+            throw new Error('track-teardown-request requiere una cohorte válida de al menos dos tracks');
+        }
+        ref.teardownRequested = true;
+        (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: trackId });
+        return;
+    }
     if (env.kind === 'track-freeze-request') {
         // R5.2/R6.3 (Task 10): request administrativa CROSS-JOURNAL — el
         // supervisor del PLAN la emite directamente al `requestsDir` de ESTE

package/dist/src/commands/watch/tracks.js

@@ -135,13 +135,22 @@ function applyProtocolToState(state, protocol) {
     // `expectedPlanHeadSha` incorrecto.
     if (protocol.planHeadSha !== undefined)
         next.cohortPlanHeadSha = protocol.planHeadSha;
-    // R7/C3 (Task 12): mismo criterio que `cohortPlanHeadSha` arriba — valores
-    // que solo avanzan (nunca retroceden a `undefined` una vez fijados por
-    // `reconcileProtocol`).
-    if (protocol.globalQaHeadSha !== undefined)
-        next.globalQaHeadSha = protocol.globalQaHeadSha;
-    if (protocol.finalIntegrationJobId !== undefined)
-        next.finalIntegrationJobId = protocol.finalIntegrationJobId;
+    // R7/C3 (Task 12): los valores finales normalmente solo avanzan, salvo
+    // que fallback abandone explícitamente esa ruta. En ese caso el reducer
+    // ya invalidó su evidencia y el mirror durable DEBE borrarla también;
+    // conservarla permitiría que un restart reconstruyera un protocolo que
+    // contradice los tracks en teardown.
+    if (protocol.cohortPhase === 'FALLBACK_PENDING') {
+        next.globalQaHeadSha = undefined;
+        next.finalIntegrationJobId = undefined;
+        next.qaFinalizeRequested = undefined;
+    }
+    else {
+        if (protocol.globalQaHeadSha !== undefined)
+            next.globalQaHeadSha = protocol.globalQaHeadSha;
+        if (protocol.finalIntegrationJobId !== undefined)
+            next.finalIntegrationJobId = protocol.finalIntegrationJobId;
+    }
     if (protocol.fallbackReason !== undefined)
         next.cohortFallbackReason = protocol.fallbackReason;
     next.tracks = (next.tracks ?? []).map((ref) => {
@@ -818,6 +827,46 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
         if (s.tracks === undefined || s.tracks.length < 2 || s.cohortPhase === undefined) {
             return { state: s, effectExecuted: null };
         }
+        // La request de teardown se consume en dos pasos durables, igual que
+        // join: `apply.ts` solo deja el marcador y este reconciler traduce la
+        // intención al reducer. BLOCKED, SERIAL y COMPLETE no admiten nueva
+        // transición: limpiar únicamente el marcador preserva el estado seguro.
+        const pendingTeardown = (s.tracks ?? []).find((track) => track.teardownRequested === true);
+        if (pendingTeardown !== undefined) {
+            const moot = ['BLOCKED', 'SERIAL', 'COMPLETE'].includes(s.cohortPhase);
+            if (moot) {
+                const next = structuredClone(s);
+                for (const track of next.tracks ?? [])
+                    if (track.trackId === pendingTeardown.trackId)
+                        track.teardownRequested = undefined;
+                s = persist(planRoot, branch, next);
+                (0, store_1.appendEvent)(planRoot, branch, {
+                    kind: 'track-teardown-moot', trackId: pendingTeardown.trackId, phase: s.cohortPhase,
+                });
+                return { state: s, effectExecuted: null };
+            }
+            const protocolBefore = toProtocol(s, maxParallel);
+            const observed = (0, protocol_1.reconcileProtocol)(protocolBefore, { kind: 'teardown-requested', trackId: pendingTeardown.trackId });
+            const next = applyProtocolToState(s, observed);
+            for (const track of next.tracks ?? [])
+                if (track.trackId === pendingTeardown.trackId)
+                    track.teardownRequested = undefined;
+            s = persist(planRoot, branch, next);
+            // El lock pertenece al proceso vivo que alcanzó la integración.
+            // Al abandonar FINAL_INTERLOCK debe soltarse en este mismo proceso;
+            // tras un crash el lease muerto se reclama por identidad al iniciar.
+            if (protocolBefore.cohortPhase === 'FINAL_INTERLOCK' && s.cohortPhase === 'FALLBACK_PENDING') {
+                runtime.releaseIntegrationLockIfHeld();
+            }
+            (0, store_1.appendEvent)(planRoot, branch, {
+                kind: 'track-teardown-observed', trackId: pendingTeardown.trackId,
+                phase: s.tracks?.find((t) => t.trackId === pendingTeardown.trackId)?.phase,
+            });
+            // El marcador es una frontera durable por sí mismo. No se consume
+            // otro marcador ni se entra a begin-teardown hasta la siguiente
+            // llamada, para que un crash conserve el resto de las requests.
+            return { state: s, effectExecuted: null };
+        }
         // El pedido de join del controller (`joinRequested`, marcado declarativamente al
         // consumir `track-join-request`) se convierte ACÁ en la observación que el reducer
         // entiende. La regla de si eso mueve la fase vive en `reconcileProtocol` (solo

package/dist/src/core/journal/types.js

@@ -246,6 +246,7 @@ function isWellFormedTrackRef(x) {
         && (x.supervisorProcessRef === undefined || isWellFormedProcessRef(x.supervisorProcessRef))
         && (x.joinIntent === undefined || isWellFormedJoinIntent(x.joinIntent))
         && (x.teardownIntent === undefined || isWellFormedTeardownIntent(x.teardownIntent))
+        && (x.teardownRequested === undefined || typeof x.teardownRequested === 'boolean')
         && (x.joinedCommitSha === undefined || typeof x.joinedCommitSha === 'string')
         && (x.blockedReason === undefined || typeof x.blockedReason === 'string');
 }

package/dist/src/core/tracks/git.js

@@ -136,13 +136,25 @@ function ownedWorktreeExists(repo, worktreePath, branch) {
  *  worktree (contenido de filesystem que SÍ podría ser ajeno), una branch es
  *  solo un ref; nada más crea una con ese nombre exacto. */
 function branchExists(repo, branch) {
+    // `show-ref --quiet` puede devolver 1 tanto para una ref ausente como
+    // para un repositorio que ni siquiera pudo abrirse. Primero probamos que
+    // git puede identificar el repositorio; solo después status 1 significa
+    // honestamente "la branch no existe".
+    try {
+        git(repo, ['rev-parse', '--git-dir']);
+    }
+    catch (error) {
+        throw new Error(`branchExists: repo de ${branch} indemostrable: ${error.message}`);
+    }
     try {
         git(repo, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
-        return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        if (error.status === 1)
+            return false;
+        throw new Error(`branchExists: existencia de ${branch} indemostrable: ${error.message}`);
     }
+    return true;
 }
 /** Task 9 (paso BRANCH_REMOVED, Task 13 endurece el guard — R4.10/C9): borra
  *  la branch local determinista de un track SOLO después de que su worktree

package/dist/src/core/tracks/protocol.js

@@ -269,7 +269,25 @@ function nextProtocolEffect(s) {
 }
 function reconcileProtocol(s, observation) {
     const out = structuredClone(s);
-    if (observation.kind === 'prepare-failed') {
+    if (observation.kind === 'teardown-requested') {
+        const requested = out.tracks[observation.trackId];
+        if (requested === undefined)
+            throw new Error(`track desconocido: ${observation.trackId}`);
+        if (out.cohortPhase !== 'BLOCKED' && out.cohortPhase !== 'SERIAL' && out.cohortPhase !== 'COMPLETE'
+            && out.cohortPhase !== 'FALLBACK_PENDING') {
+            out.cohortPhase = 'FALLBACK_PENDING';
+            out.fallbackReason = `controller-requested:${observation.trackId}`;
+            // La evidencia de QA/integración describe la ruta de finalización
+            // que acabamos de abandonar. Debe desaparecer ANTES de mover los
+            // tracks a teardown: de otro modo el invariante de integración
+            // final ve evidence viva junto a tracks no mergeados y rechaza la
+            // transición segura hacia fallback.
+            out.globalQaHeadSha = undefined;
+            out.finalIntegrationJobId = undefined;
+            markTeardownRequested(out.tracks);
+        }
+    }
+    else if (observation.kind === 'prepare-failed') {
         out.cohortPhase = 'FALLBACK_PENDING';
         out.fallbackReason = `prepare-failed:${observation.trackId}`;
         markTeardownRequested(out.tracks);
@@ -295,10 +313,11 @@ function reconcileProtocol(s, observation) {
             // `decideTeardown` documenta para BLOCKED: solo el operador lo
             // saca de acá.
             const t = out.tracks[observation.trackId];
-            if (t !== undefined) {
-                t.phase = 'BLOCKED';
-                t.blockedReason = observation.detail;
-            }
+            if (t === undefined)
+                throw new Error(`track desconocido: ${observation.trackId}`);
+            t.phase = 'BLOCKED';
+            t.blockedReason = observation.detail;
+            out.cohortPhase = 'BLOCKED';
         }
         // effect-failed fuera de PREPARING/begin-teardown: sin transición definida todavía (no ejercitado por T1).
     }
@@ -351,6 +370,7 @@ function reconcileProtocol(s, observation) {
         if (decision === 'block-foreign') {
             t.phase = 'BLOCKED';
             t.blockedReason = observation.foreignSupervisor ? 'identidad de supervisor ajena' : 'worktree preexistente ajeno';
+            out.cohortPhase = 'BLOCKED';
         }
         else if (decision === 'accept-supervisor-stopped') {
             t.phase = 'SUPERVISOR_STOPPED';
@@ -432,7 +452,7 @@ function reconcileProtocol(s, observation) {
 }
 function observeProtocolEffect(s, effect, observation) {
     if (observation.kind === 'effect-failed' || observation.kind === 'prepare-failed' || observation.kind === 'join-observation'
-        || observation.kind === 'freeze-observation' || observation.kind === 'join-requested'
+        || observation.kind === 'freeze-observation' || observation.kind === 'join-requested' || observation.kind === 'teardown-requested'
         || observation.kind === 'supervisor-observed' || observation.kind === 'worktree-observed'
         || observation.kind === 'teardown-observation'
         || observation.kind === 'global-qa-pass'

package/dist/tests/commands/track/verbs.test.js

@@ -103,6 +103,12 @@ describe('awm track — verbos mutantes son request-only (R6.1)', () => {
         expect(git(repo, ['rev-parse', 'HEAD'])).toBe(beforeHead);
         expect(fs_1.default.readFileSync((0, paths_1.statePath)(repo, branch), 'utf8')).toBe(beforeState);
     });
+    test('remove se anuncia como cancelación request-only soportada (TR-REQ-10)', async () => {
+        const out = await runCli(repo, ['track', 'remove', '--help']);
+        expect(out.exitCode).toBe(0);
+        expect(out.out).toContain('cancela la cohorte');
+        expect(out.out).not.toContain('NO IMPLEMENTADO');
+    });
     // `finalize` es PLAN-scoped y sin <trackId>, así que no entra en las matrices de
     // add/join/remove — pero comparte con ellas la propiedad que define a la superficie:
     // emite una request y no toca Git ni state.json.

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

@@ -126,7 +126,7 @@ describe('aplicacion transaccional de requests', () => {
         expect(Object.keys((0, store_1.readJournal)(repo, 'rama').state.jobs)).toHaveLength(1); // sin duplicados
     });
     test('register-entity CREA task con VerificationPlan y ReviewObligations; cycle-plan y dispatch (R1.4/R1.4b)', () => {
-        (0, requests_1.emitRequest)(repo, 'rama', {
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
             kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
             payload: {
                 entity: 'task', taskId: 'T1', title: 'implementar',
@@ -513,20 +513,57 @@ describe('aplicacion transaccional de requests', () => {
         expect(out.rejectedInvalid).toBe(1);
         expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
     });
-    test('un kind SIN handler falla cerrado: rechazo visible, no un `applied` que borra el archivo', () => {
-        // `track-teardown-request` es un kind real, emitido por `awm track remove`, que hoy
-        // no tiene handler en el supervisor. Antes de este cambio se contaba como aplicado y
-        // desaparecía sin dejar rastro; ahora queda registrado como problema y el archivo se
-        // conserva con sufijo `.rejected`, que es lo que permite darse cuenta.
-        const r = (0, requests_1.emitRequest)(repo, 'rama', {
-            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-1',
+    test('track-teardown-request persiste intención sin mover fase ni cohorte', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-alpha',
             payload: { trackId: 'alpha' },
         });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tracks[0].teardownRequested).toBe(true);
+        expect(state.tracks[0].phase).toBe('ACTIVE');
+        expect(state.cohortPhase).toBe('JOINING');
+        expect(state.appliedRequests[request.requestId]).toMatchObject({ outcome: 'applied', resultRef: 'alpha' });
+    });
+    test.each([
+        ['ausente', {}],
+        ['vacio', { trackId: '' }],
+        ['malformado', { trackId: 42 }],
+        ['desconocido', { trackId: 'no-existe' }],
+    ])('track-teardown-request %s se rechaza visiblemente sin mutar el track', (_case, payload) => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: `teardown-${_case}`,
+            payload,
+        });
         const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
         expect(out.applied).toBe(0);
         expect(out.rejectedInvalid).toBe(1);
         expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
-        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems.some((p) => p.kind === 'rejected')).toBe(true);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tracks).toEqual([{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }]);
+        expect(state.cohortPhase).toBe('JOINING');
+    });
+    test('track-teardown-request se rechaza si la cohorte no puede reconciliarse', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-invalid-cohort',
+            payload: { trackId: 'alpha' },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${request.file}.rejected`)).toBe(true);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tracks[0].teardownRequested).toBeUndefined();
     });
     test('track-finalize-request persiste el autoreporte del controller (qaFinalizeRequested) — puramente declarativo (R7.2)', () => {
         (0, requests_1.emitRequest)(repo, 'rama', {

package/dist/tests/commands/watch/track-remove-request.test.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const git_fixture_1 = require("../../helpers/git-fixture");
+const tracks_1 = require("../../../src/commands/watch/tracks");
+const apply_1 = require("../../../src/commands/watch/apply");
+const emit_1 = require("../../../src/commands/track/emit");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const BRANCH = 'main';
+describe('awm track remove -> fallback teardown', () => {
+    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');
+        (0, store_1.initJournal)(planRoot, BRANCH);
+    });
+    afterEach(() => fs_1.default.rmSync(planRoot, { recursive: true, force: true }));
+    function declareCohort(cohortPhase = 'ACTIVE') {
+        const state = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        state.cohortPhase = cohortPhase;
+        state.cohortBaseSha = baseSha;
+        state.tracks = ['a', 'b'].map((trackId) => ({
+            trackId, worktreePath: path_1.default.join(planRoot, `../nope-${trackId}`), branch: `awm-track/${trackId}`,
+            ownership: [], sharedResources: [], dependsOn: [], fencingToken: `fence-${trackId}`.padEnd(32, '0'),
+            phase: 'ACTIVE', readinessNonce: `ready-${trackId}`.padEnd(32, '0'),
+        }));
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        return (0, store_1.readJournal)(planRoot, BRANCH).state;
+    }
+    function inertRuntime() {
+        const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+        return { ...real,
+            addWorktree: () => { throw new Error('no external mutation expected'); },
+            initTrackJournal: () => { throw new Error('no external mutation expected'); },
+            spawnSupervisor: () => { throw new Error('no external mutation expected'); },
+            stopOwnSupervisor: () => { throw new Error('no external mutation expected'); },
+            removeOwnedWorktree: () => { throw new Error('no external mutation expected'); },
+            removeOwnedBranch: () => { throw new Error('no external mutation expected'); },
+        };
+    }
+    function events() {
+        if (!fs_1.default.existsSync((0, paths_1.eventsPath)(planRoot, BRANCH)))
+            return [];
+        return fs_1.default.readFileSync((0, paths_1.eventsPath)(planRoot, BRANCH), 'utf8').trim().split('\n').filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    it('consume el marker antes que join y persiste fallback cohort-wide (TR-REQ-03, TR-REQ-04)', async () => {
+        const state = declareCohort();
+        state.tracks[0].joinRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'b');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        // Consumir el marcador es su propia frontera durable: el teardown
+        // empieza recién en la siguiente llamada.
+        expect(out.effectExecuted).toBeNull();
+        expect(out.state.cohortFallbackReason).toBe('controller-requested:b');
+        expect(out.state.tracks?.find((track) => track.trackId === 'b')?.teardownRequested)
+            .toBeUndefined();
+        expect(events().some((event) => event.kind === 'track-teardown-observed' && event.trackId === 'b'))
+            .toBe(true);
+    });
+    it('un marker sobreviviente a restart converge por el mismo reducer (TR-REQ-07)', async () => {
+        const state = declareCohort();
+        state.tracks[0].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(out.state.tracks[0].teardownRequested).toBeUndefined();
+    });
+    it.each(['SERIAL', 'COMPLETE'])('consume remove tardío como moot en %s (TR-REQ-09)', async (phase) => {
+        const state = declareCohort(phase);
+        for (const track of state.tracks) {
+            track.phase = phase === 'SERIAL' ? 'REMOVED' : 'JOINED';
+            track.frozenHeadSha = phase === 'COMPLETE' ? baseSha : undefined;
+        }
+        state.tracks[0].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe(phase);
+        expect(out.state.tracks[0].teardownRequested).toBeUndefined();
+        expect(events()).toContainEqual(expect.objectContaining({ kind: 'track-teardown-moot', trackId: 'a', phase }));
+    });
+    it('una request en cohorte BLOCKED es moot y no reabre fallback', async () => {
+        const state = declareCohort('BLOCKED');
+        state.tracks[0].phase = 'BLOCKED';
+        state.tracks[1].phase = 'REMOVED';
+        state.tracks[1].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.effectExecuted).toBeNull();
+        expect(out.state.cohortPhase).toBe('BLOCKED');
+        expect(out.state.tracks[1].teardownRequested).toBeUndefined();
+        expect(events()).toContainEqual(expect.objectContaining({ kind: 'track-teardown-moot', trackId: 'b', phase: 'BLOCKED' }));
+    });
+    it('consume exactamente un marcador de teardown por reconcile antes de begin-teardown (issue #93)', async () => {
+        const s = declareCohort('ACTIVE');
+        s.tracks.forEach((track) => { track.teardownRequested = true; });
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        const first = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(first.effectExecuted).toBeNull();
+        expect(first.state.tracks?.find((track) => track.trackId === 'a')?.teardownRequested).toBeUndefined();
+        expect(first.state.tracks?.find((track) => track.trackId === 'b')?.teardownRequested).toBe(true);
+        const second = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, first.state, inertRuntime(), 2);
+        expect(second.effectExecuted).toBeNull();
+        expect(second.state.tracks?.every((track) => track.teardownRequested === undefined)).toBe(true);
+    });
+    it('una request repetida durante teardown no rebobina fases ni ejecuta trabajo destructivo (issue #93)', async () => {
+        declareCohort('ACTIVE');
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        const afterFirst = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g2', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g2');
+        const repeated = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(afterFirst.state.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('TEARDOWN_REQUESTED');
+        expect(repeated.effectExecuted).toBeNull();
+        expect(repeated.state.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('TEARDOWN_REQUESTED');
+        expect(repeated.state.cohortPhase).toBe('FALLBACK_PENDING');
+    });
+    it('request durante FINAL_INTERLOCK persiste fallback sin evidencia final stale (issue #93)', async () => {
+        const s = declareCohort('FINAL_INTERLOCK');
+        for (const track of s.tracks)
+            track.phase = 'MERGED_UNVERIFIED';
+        for (const track of s.tracks)
+            track.frozenHeadSha = `${track.trackId}-head`;
+        s.globalQaHeadSha = 'qa-head';
+        s.finalIntegrationJobId = 'integration-job';
+        s.qaFinalizeRequested = { headSha: 'qa-head', at: new Date().toISOString() };
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        let releases = 0;
+        const runtime = { ...inertRuntime(), releaseIntegrationLockIfHeld: () => { releases += 1; } };
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, runtime, 2);
+        const durable = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(durable.globalQaHeadSha).toBeUndefined();
+        expect(durable.finalIntegrationJobId).toBeUndefined();
+        expect(durable.qaFinalizeRequested).toBeUndefined();
+        expect(durable.tracks?.every((track) => track.phase === 'TEARDOWN_REQUESTED')).toBe(true);
+        expect(releases).toBe(1);
+    });
+    it('un probe de branch indemostrable detiene teardown sin serializar (issue #93)', async () => {
+        const s = declareCohort('FALLBACK_PENDING');
+        s.tracks[0].phase = 'WORKTREE_REMOVED';
+        s.tracks[1].phase = 'REMOVED';
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        const gitDir = path_1.default.join(planRoot, '.git');
+        fs_1.default.renameSync(gitDir, `${gitDir}.unavailable`);
+        await expect((0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH), 2)).rejects.toThrow(/indemostrable/);
+        fs_1.default.renameSync(`${gitDir}.unavailable`, gitDir);
+        const durable = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(durable.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(durable.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('WORKTREE_REMOVED');
+    });
+});

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

@@ -23,6 +23,8 @@ 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 apply_1 = require("../../../src/commands/watch/apply");
+const emit_1 = require("../../../src/commands/track/emit");
 const git_1 = require("../../../src/core/tracks/git");
 const descriptor_1 = require("../../../src/core/tracks/descriptor");
 const BRANCH = 'main';
@@ -263,6 +265,31 @@ describe('reconcileTracks — crash/restart de teardown con git real (Task 13, R
         expect(fs_1.default.existsSync(path_1.default.join(root, 'track-a'))).toBe(false);
         expect(branchListed(planRoot, 'awm-track/a')).toBe(false);
     });
+    test('request bridge sobrevive crash tras el marcador y converge a SERIAL sin repetir remociones (issue #93)', async () => {
+        let s = declareCohort(planRoot, root, baseSha);
+        materializeTrackA(s);
+        s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        s.cohortPhase = 'PREPARING';
+        s.tracks = s.tracks.map((track) => track.trackId === 'a'
+            ? { ...track, phase: 'WORKTREE_CREATED', supervisorProcessRef: deadRef() }
+            : track);
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        expect((0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1').applied).toBe(1);
+        // Crash immediately after the request marker becomes the durable
+        // protocol observation: no teardown effect has run yet.
+        s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, buildRuntime(planRoot, []), 2)).state;
+        expect(trackA(s).phase).toBe('TEARDOWN_REQUESTED');
+        const effects = [];
+        const restarted = buildRuntime(planRoot, effects);
+        for (let i = 0; i < 20 && s.cohortPhase !== 'SERIAL'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, restarted, 2)).state;
+        }
+        expect(s.cohortPhase).toBe('SERIAL');
+        expect(trackA(s).phase).toBe('REMOVED');
+        expect(effects.filter((effect) => effect === 'worktree-effect:a')).toHaveLength(1);
+        expect(effects.filter((effect) => effect === 'branch-effect:awm-track/a')).toHaveLength(1);
+    });
     // 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

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

@@ -148,6 +148,17 @@ describe('journal types', () => {
         state.tracks[0].supervisorIntent.nonce = '';
         expect((0, types_1.isWellFormedState)(state)).toBe(false);
     });
+    test('TrackRef acepta teardownRequested booleano y rechaza otro runtime shape', () => {
+        const state = (0, types_1.emptyState)('main');
+        state.tracks = [{
+                trackId: 'cli', worktreePath: '/tmp/wt', branch: 'awm-track/cli', ownership: ['cli/'],
+                sharedResources: [], dependsOn: [], fencingToken: 'f'.repeat(32), phase: 'ACTIVE',
+                readinessNonce: 'r'.repeat(32), teardownRequested: true,
+            }];
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.tracks[0].teardownRequested = 'true';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
     test('trackContext, cohortPhase y trackIntegration validan shape cuando presentes (R9.1, R9.3)', () => {
         const state = (0, types_1.emptyState)('main');
         state.trackContext = { trackId: 'cli', taskIds: ['t1'], planDigest: 'd', baseSha: 'abc', planJournalId: 'j-plan' };

package/dist/tests/core/tracks/git.test.js

@@ -128,5 +128,12 @@ describe('git adapter', () => {
             (0, child_process_1.execFileSync)('git', ['branch', 'awm-track/x'], { cwd: repo });
             expect((0, git_1.branchExists)(repo, 'awm-track/x')).toBe(true);
         });
+        test('branchExists falla cerrado cuando git no puede probar la ausencia', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            const gitDir = path_1.default.join(repo, '.git');
+            fs_1.default.renameSync(gitDir, `${gitDir}.unavailable`);
+            expect(() => (0, git_1.branchExists)(repo, 'awm-track/nope')).toThrow(/indemostrable/);
+        });
     });
 });

package/dist/tests/core/tracks/protocol.test.js

@@ -34,6 +34,109 @@ describe('parallel-track protocol model', () => {
         expect(() => (0, protocol_1.observeProtocolEffect)(s, { kind: 'enter-serial', reason: 'x' }, { kind: 'effect-applied', effect: { kind: 'enter-serial', reason: 'x' } }))
             .toThrow(/SERIAL prohíbe recursos paralelos activos/);
     });
+    test.each([
+        {
+            name: 'observación de ownership ajeno',
+            observation: { kind: 'teardown-observation', trackId: 'cli', foreignWorktree: true },
+        },
+        {
+            name: 'fallo de begin-teardown',
+            observation: {
+                kind: 'effect-failed', trackId: 'cli', effect: 'begin-teardown', detail: 'ownership indemostrable',
+            },
+        },
+    ])('teardown indemostrable bloquea track y cohorte: $name (TR-REQ-05)', ({ observation }) => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FALLBACK_PENDING';
+        s.fallbackReason = 'controller-requested:cli';
+        s.tracks.cli.phase = 'TEARDOWN_REQUESTED';
+        s.tracks.docs.phase = 'REMOVED';
+        const out = (0, protocol_1.reconcileProtocol)(s, observation);
+        expect(out.tracks.cli.phase).toBe('BLOCKED');
+        expect(out.cohortPhase).toBe('BLOCKED');
+        expect((0, protocol_1.nextProtocolEffect)(out)).toBeNull();
+    });
+    test('fallo de begin-teardown para track inexistente falla cerrado (TR-REQ-05)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FALLBACK_PENDING';
+        expect(() => (0, protocol_1.reconcileProtocol)(s, {
+            kind: 'effect-failed', trackId: 'missing', effect: 'begin-teardown', detail: 'ownership indemostrable',
+        })).toThrow('track desconocido: missing');
+    });
+    test('remove cancela toda la cohorte activa y conserva DECLARED/BLOCKED (TR-REQ-03, TR-REQ-05)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ['active', 'declared', 'blocked']);
+        s.cohortPhase = 'ACTIVE';
+        s.tracks.active.phase = 'ACTIVE';
+        s.tracks.declared.phase = 'DECLARED';
+        s.tracks.blocked.phase = 'BLOCKED';
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'active' });
+        expect(out.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(out.fallbackReason).toBe('controller-requested:active');
+        expect(out.tracks.active.phase).toBe('TEARDOWN_REQUESTED');
+        expect(out.tracks.declared.phase).toBe('DECLARED');
+        expect(out.tracks.blocked.phase).toBe('BLOCKED');
+        expect((0, protocol_1.nextProtocolEffect)(out)).toBeNull();
+    });
+    test('remove durante FINAL_INTERLOCK invalida evidencia final antes de pedir teardown (issue #93)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FINAL_INTERLOCK';
+        s.globalQaHeadSha = 'qa-head';
+        s.finalIntegrationJobId = 'integration-job';
+        for (const track of Object.values(s.tracks)) {
+            track.phase = 'MERGED_UNVERIFIED';
+            track.frozenHeadSha = `${track.trackId}-head`;
+        }
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'cli' });
+        expect(out.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(out.globalQaHeadSha).toBeUndefined();
+        expect(out.finalIntegrationJobId).toBeUndefined();
+        expect(Object.values(out.tracks).every((track) => track.phase === 'TEARDOWN_REQUESTED')).toBe(true);
+    });
+    test('remove repetido no rebobina teardown ni reemplaza la causa (TR-REQ-08)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FALLBACK_PENDING';
+        s.fallbackReason = 'controller-requested:cli';
+        s.tracks.cli.phase = 'SUPERVISOR_STOPPED';
+        s.tracks.docs.phase = 'TEARDOWN_REQUESTED';
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'docs' });
+        expect(out.fallbackReason).toBe('controller-requested:cli');
+        expect(out.tracks.cli.phase).toBe('SUPERVISOR_STOPPED');
+        expect(out.tracks.docs.phase).toBe('TEARDOWN_REQUESTED');
+    });
+    test.each(['SERIAL', 'COMPLETE'])('remove es no-op protocolar en cohorte terminal %s (TR-REQ-09)', (cohortPhase) => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = cohortPhase;
+        for (const track of Object.values(s.tracks)) {
+            track.phase = cohortPhase === 'SERIAL' ? 'REMOVED' : 'JOINED';
+            if (cohortPhase === 'COMPLETE')
+                track.frozenHeadSha = `${track.trackId}-head`;
+        }
+        expect((0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'cli' })).toEqual(s);
+    });
+    test('remove es no-op protocolar en cohorte BLOCKED y no reanuda teardown (TR-REQ-10)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'BLOCKED';
+        s.tracks.cli.phase = 'BLOCKED';
+        s.tracks.cli.blockedReason = 'ownership indemostrable';
+        s.tracks.docs.phase = 'REMOVED';
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'docs' });
+        expect(out).toEqual(s);
+        expect(out.cohortPhase).toBe('BLOCKED');
+        expect((0, protocol_1.nextProtocolEffect)(out)).toBeNull();
+    });
+    test('remove converge a serial solo después de desmontar la cohorte (TR-REQ-06)', () => {
+        let s = (0, protocol_1.initialCohort)('journal-1', ids);
+        for (const track of Object.values(s.tracks))
+            track.phase = 'ACTIVE';
+        s.cohortPhase = 'ACTIVE';
+        s = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'cli' });
+        expect((0, protocol_1.nextProtocolEffect)(s)).toEqual({ kind: 'begin-teardown', trackId: 'cli' });
+        s.tracks.cli.phase = 'REMOVED';
+        s.tracks.docs.phase = 'REMOVED';
+        expect((0, protocol_1.nextProtocolEffect)(s)).toEqual({
+            kind: 'enter-serial', reason: 'controller-requested:cli',
+        });
+    });
     test('ningún merge empieza antes de que todos los tracks estén FROZEN (C3)', () => {
         const s = (0, protocol_1.initialCohort)('journal-1', ids);
         s.cohortPhase = 'JOINING';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.6.1",
+  "version": "9.7.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"