agentic-workflow-manager 9.7.1 → 9.9.0

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

@@ -3,11 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRef = exports.refOf = exports.persist = exports.applyProtocolToState = void 0;
 exports.canCompleteCohort = canCompleteCohort;
-exports.applyProtocolToState = applyProtocolToState;
-exports.persist = persist;
-exports.refOf = refOf;
-exports.withRef = withRef;
 exports.reconcileTracks = reconcileTracks;
 exports.reconcileOpenJoin = reconcileOpenJoin;
 exports.observeSupervisorFromDisk = observeSupervisorFromDisk;
@@ -34,6 +31,12 @@ const ownership_1 = require("../../core/tracks/ownership");
 const descriptor_1 = require("../../core/tracks/descriptor");
 const join_1 = require("../../core/tracks/join");
 const teardown_driver_1 = require("./teardown-driver");
+const track_state_1 = require("./track-state");
+var track_state_2 = require("./track-state");
+Object.defineProperty(exports, "applyProtocolToState", { enumerable: true, get: function () { return track_state_2.applyProtocolToState; } });
+Object.defineProperty(exports, "persist", { enumerable: true, get: function () { return track_state_2.persist; } });
+Object.defineProperty(exports, "refOf", { enumerable: true, get: function () { return track_state_2.refOf; } });
+Object.defineProperty(exports, "withRef", { enumerable: true, get: function () { return track_state_2.withRef; } });
 const request_1 = require("../job/request");
 const gate_1 = require("../job/gate");
 const process_2 = require("../../core/journal/process");
@@ -119,73 +122,6 @@ function toProtocol(state, maxParallel) {
         fallbackReason: state.cohortFallbackReason,
     };
 }
-/** Vuelca las decisiones de `protocol.ts` de regreso al `TrackRef[]` real —
- *  nunca al revés: esta función jamás decide, solo transcribe. Exportada
- *  (junto con `persist`/`refOf`/`withRef`/`EffectRunResult` más abajo) para
- *  que `./teardown-driver` — que ejecuta el mismo patrón "gather -> decide ->
- *  tocar el mundo real como mucho una vez -> persistir -> stop" que todo
- *  `run*` de este archivo — reutilice estos helpers sin duplicarlos. */
-function applyProtocolToState(state, protocol) {
-    const next = structuredClone(state);
-    next.cohortPhase = protocol.cohortPhase;
-    // R6.2/R6.3/C7 (Task 11): persistir el HEAD del plan avanzado por
-    // `reconcileProtocol`'s `accept-merge` (`out.planHeadSha = decision.
-    // joinedCommitSha`) — sin esto, el siguiente `toProtocol` volvería a leer
-    // `cohortBaseSha` (stale) y el segundo join de la cohorte usaría un
-    // `expectedPlanHeadSha` incorrecto.
-    if (protocol.planHeadSha !== undefined)
-        next.cohortPlanHeadSha = protocol.planHeadSha;
-    // 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) => {
-        const t = protocol.tracks[ref.trackId];
-        if (t === undefined)
-            return ref;
-        return {
-            ...ref,
-            phase: t.phase,
-            frozenHeadSha: t.frozenHeadSha,
-            blockedReason: t.blockedReason,
-            joinedCommitSha: t.joinedCommitSha,
-            joinIntent: t.expectedPlanHeadSha !== undefined && t.expectedTrackHeadSha !== undefined
-                ? { expectedPlanHeadSha: t.expectedPlanHeadSha, expectedTrackHeadSha: t.expectedTrackHeadSha, strategy: types_1.JOIN_STRATEGY_NO_FF }
-                : ref.joinIntent,
-        };
-    });
-    return next;
-}
-function persist(planRoot, branch, s) {
-    (0, store_1.writeJournal)(planRoot, branch, s);
-    const r = (0, store_1.readJournal)(planRoot, branch);
-    if (r.corrupt || r.state === null)
-        throw new Error('journal corrupto tras persistir tracks (R1.6)');
-    return r.state;
-}
-function refOf(s, trackId) {
-    const ref = s.tracks?.find((t) => t.trackId === trackId);
-    if (ref === undefined)
-        throw new Error(`invariante rota: TrackRef ausente para ${trackId}`);
-    return ref;
-}
-function withRef(s, trackId, patch) {
-    return { ...s, tracks: (s.tracks ?? []).map((t) => (t.trackId === trackId ? { ...t, ...patch } : t)) };
-}
 function mustBaseSha(s) {
     if (s.cohortBaseSha === undefined)
         throw new Error('invariante rota: cohortBaseSha ausente para una cohorte en PREPARING/ACTIVE');
@@ -193,7 +129,7 @@ function mustBaseSha(s) {
 }
 function runCreateWorktree(planRoot, branch, s, protocol, effect, runtime) {
     const trackId = effect.trackId;
-    const ref = refOf(s, trackId);
+    const ref = (0, track_state_1.refOf)(s, trackId);
     // Task 9 (R4.2/R4.6/C11): observaciones read-only del mundo real ANTES de
     // tocar `runtime` — ninguna de las dos cuenta como el side effect del
     // tick, igual que documentaba la versión anterior de este comentario.
@@ -209,13 +145,13 @@ function runCreateWorktree(planRoot, branch, s, protocol, effect, runtime) {
     const decision = (0, protocol_1.decidePrepare)(protocol.tracks[trackId], observed);
     if (decision === 'accept-worktree') {
         const applied = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'worktree-observed', trackId, owned: true });
-        const next = persist(planRoot, branch, applyProtocolToState(s, applied));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, applied));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-effect', trackId, effect: effect.kind });
         return { state: next, stop: true, executed: effect.kind };
     }
     if (decision === 'block-foreign') {
         const blocked = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'worktree-observed', trackId, owned: false });
-        const next = persist(planRoot, branch, applyProtocolToState(s, blocked));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, blocked));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-blocked', trackId, reason: 'worktree preexistente ajeno' });
         // Post-review fix (Task 8): bloquear un track es en sí mismo UNA
         // frontera — dejar `stop:false` acá permitía que el MISMO call
@@ -232,18 +168,18 @@ function runCreateWorktree(planRoot, branch, s, protocol, effect, runtime) {
     }
     catch (error) {
         const failed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'effect-failed', trackId, effect: effect.kind, detail: error.message });
-        const next = persist(planRoot, branch, applyProtocolToState(s, failed));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, failed));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-effect-failed', trackId, effect: effect.kind, detail: error.message });
         return { state: next, stop: true, executed: effect.kind };
     }
     const applied = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'worktree-observed', trackId, owned: true });
-    const next = persist(planRoot, branch, applyProtocolToState(s, applied));
+    const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, applied));
     (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-effect', trackId, effect: effect.kind });
     return { state: next, stop: true, executed: effect.kind };
 }
 function runCreateTrackJournal(planRoot, branch, s, protocol, effect, runtime) {
     const trackId = effect.trackId;
-    const ref = refOf(s, trackId);
+    const ref = (0, track_state_1.refOf)(s, trackId);
     // GAP CONOCIDO Y DELIBERADAMENTE DIFERIDO (ver el comentario largo en
     // `apply.ts` junto a `track-prepare-request`): `taskIds`/`planDigest`
     // deberían nacer del plan .md parseado, pero NINGÚN task (1-8) provee un
@@ -270,12 +206,12 @@ function runCreateTrackJournal(planRoot, branch, s, protocol, effect, runtime) {
     }
     catch (error) {
         const failed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'effect-failed', trackId, effect: effect.kind, detail: error.message });
-        const next = persist(planRoot, branch, applyProtocolToState(s, failed));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, failed));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-effect-failed', trackId, effect: effect.kind, detail: error.message });
         return { state: next, stop: true, executed: effect.kind };
     }
     const applied = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'effect-applied', effect });
-    const next = persist(planRoot, branch, applyProtocolToState(s, applied));
+    const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, applied));
     (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-effect', trackId, effect: effect.kind });
     return { state: next, stop: true, executed: effect.kind };
 }
@@ -300,7 +236,7 @@ function runCreateTrackJournal(planRoot, branch, s, protocol, effect, runtime) {
  *  `Supervisor.tick()` del track, en su journal, en su propio proceso). */
 function runFreezeTrack(planRoot, branch, s, protocol, effect, runtime) {
     const trackId = effect.trackId;
-    const ref = refOf(s, trackId);
+    const ref = (0, track_state_1.refOf)(s, trackId);
     const r = (0, store_1.readJournal)(ref.worktreePath, ref.branch);
     if (r.corrupt || r.state === null) {
         // Journal del track todavía no legible (crash entre `create-track-
@@ -331,7 +267,7 @@ function runFreezeTrack(planRoot, branch, s, protocol, effect, runtime) {
         const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, {
             kind: 'freeze-observation', trackId, frozenHeadSha: trackState.frozen.headSha,
         });
-        let next = applyProtocolToState(s, observed);
+        let next = (0, track_state_1.applyProtocolToState)(s, observed);
         // R5.7/R5.8/R5.9/C5 (Step 6): ownership REAL post-hoc, desde commits
         // YA congelados — nunca `git status` para esto (esa es la
         // herramienta de limpieza, no de ownership). `ref.ownership` es el
@@ -361,7 +297,7 @@ function runFreezeTrack(planRoot, branch, s, protocol, effect, runtime) {
                 cohortParallelInvalidatedBy: [...new Set([...(next.cohortParallelInvalidatedBy ?? []), ...marks])],
             };
         }
-        const persisted = persist(planRoot, branch, next);
+        const persisted = (0, track_state_1.persist)(planRoot, branch, next);
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-frozen-observed', trackId, frozenHeadSha: trackState.frozen.headSha });
         if (actual.outsideOwnership.length > 0) {
             (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-ownership-violation', trackId, paths: actual.outsideOwnership });
@@ -490,7 +426,7 @@ async function runMergeTrack(planRoot, branch, s, protocol, effect, runtime) {
         }
         const after = gatherJoinObservation(planRoot, intent.expectedTrackHeadSha);
         const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'join-observation', trackId, ...after });
-        const next = persist(planRoot, branch, applyProtocolToState(s, observed));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, observed));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-merge-attempted', trackId, detail });
         return { state: next, stop: true, executed: effect.kind };
     }
@@ -508,7 +444,7 @@ async function runMergeTrack(planRoot, branch, s, protocol, effect, runtime) {
         }
         const after = gatherJoinObservation(planRoot, intent.expectedTrackHeadSha);
         const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'join-observation', trackId, ...after });
-        const next = persist(planRoot, branch, applyProtocolToState(s, observed));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, observed));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-merge-aborted', trackId, detail });
         return { state: next, stop: true, executed: effect.kind };
     }
@@ -516,7 +452,7 @@ async function runMergeTrack(planRoot, branch, s, protocol, effect, runtime) {
     // ningún efecto git nuevo que ejecutar este tick (mismo criterio que
     // `runCreateWorktree`'s ramas 'accept-worktree'/'block-foreign').
     const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'join-observation', trackId, ...before });
-    const next = persist(planRoot, branch, applyProtocolToState(s, observed));
+    const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, observed));
     (0, store_1.appendEvent)(planRoot, branch, {
         kind: decision.action === 'accept-merge' ? 'track-merged' : 'track-blocked',
         trackId, ...(decision.action === 'block' ? { reason: decision.reason } : {}),
@@ -555,7 +491,7 @@ function runRequestGlobalQa(planRoot, branch, s, protocol, effect) {
         }
         if (actualHead === reported.headSha && clean) {
             const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'global-qa-pass', headSha: actualHead, clean: true });
-            const next = persist(planRoot, branch, applyProtocolToState(s, observed));
+            const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, observed));
             (0, store_1.appendEvent)(planRoot, branch, { kind: 'global-qa-passed', headSha: actualHead });
             return { state: next, stop: true, executed: effect.kind };
         }
@@ -573,7 +509,7 @@ function runRequestGlobalQa(planRoot, branch, s, protocol, effect) {
             nextAction: { actionId: 'finalize-global-qa', type: 'run-global-qa', target: 'cycle', preconditions: [], attempt: 0, state: 'pending' },
         },
     };
-    const persisted = persist(planRoot, branch, next);
+    const persisted = (0, track_state_1.persist)(planRoot, branch, next);
     (0, store_1.appendEvent)(planRoot, branch, { kind: 'global-qa-requested' });
     return { state: persisted, stop: true, executed: effect.kind };
 }
@@ -601,7 +537,7 @@ async function runRequestFinalIntegration(planRoot, branch, s, protocol, effect,
                 return { state: s, stop: true, executed: null };
             }
             const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'integration-pass', jobId: existing.id, headSha: headNow });
-            const next = persist(planRoot, branch, applyProtocolToState(s, observed));
+            const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, observed));
             (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-integration-passed', jobId: existing.id });
             return { state: next, stop: true, executed: effect.kind };
         }
@@ -659,7 +595,7 @@ function runRunFinalInterlock(planRoot, branch, s, protocol, effect, runtime) {
     if (protocol.globalQaHeadSha === undefined)
         throw new Error('invariante rota: globalQaHeadSha ausente en FINAL_INTERLOCK');
     const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'interlock-pass', headSha: protocol.globalQaHeadSha });
-    const next = persist(planRoot, branch, applyProtocolToState(s, observed));
+    const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, observed));
     runtime.releaseIntegrationLockIfHeld();
     (0, store_1.appendEvent)(planRoot, branch, { kind: 'cohort-complete' });
     return { state: next, stop: true, executed: effect.kind };
@@ -671,7 +607,7 @@ function defaultCliEntry() {
 }
 function runSpawnTrackSupervisor(planRoot, branch, s, protocol, effect, runtime) {
     const trackId = effect.trackId;
-    const ref = refOf(s, trackId);
+    const ref = (0, track_state_1.refOf)(s, trackId);
     if (ref.supervisorIntent === undefined) {
         // R1.8/C11: el intent (nonce + argv + claimPath) se persiste ANTES de
         // spawnear nada — si el supervisor del plan muere justo acá, el
@@ -688,7 +624,7 @@ function runSpawnTrackSupervisor(planRoot, branch, s, protocol, effect, runtime)
             claimPath: path_1.default.join(ref.worktreePath, '.awm', 'supervisor.claim'),
         };
         const applied = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'effect-applied', effect });
-        const next = persist(planRoot, branch, withRef(applyProtocolToState(s, applied), trackId, { supervisorIntent: intent }));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.withRef)((0, track_state_1.applyProtocolToState)(s, applied), trackId, { supervisorIntent: intent }));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-supervisor-intent', trackId });
         // Post-review fix: persistir el supervisorIntent es en sí mismo UNA
         // frontera durable (R1.8/C11) — con `stop:false` el MISMO call podía
@@ -721,7 +657,7 @@ function runSpawnTrackSupervisor(planRoot, branch, s, protocol, effect, runtime)
     const decision = (0, protocol_1.decidePrepare)(protocol.tracks[trackId], { supervisorArtifact: observation.kind });
     if (decision === 'block-foreign') {
         const blocked = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'supervisor-observed', trackId, identity: 'other' });
-        const next = persist(planRoot, branch, applyProtocolToState(s, blocked));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, blocked));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-blocked', trackId, reason: 'identidad de supervisor ajena' });
         return { state: next, stop: true, executed: null };
     }
@@ -733,7 +669,7 @@ function runSpawnTrackSupervisor(planRoot, branch, s, protocol, effect, runtime)
             // mutante por invocación — igual patrón que
             // `foreignPathExists` -> `addWorktree` en `runCreateWorktree`.
             const pr = runtime.spawnSupervisor(ref);
-            const next = pr !== undefined ? persist(planRoot, branch, withRef(s, trackId, { supervisorProcessRef: pr })) : s;
+            const next = pr !== undefined ? (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.withRef)(s, trackId, { supervisorProcessRef: pr })) : s;
             (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-effect', trackId, effect: effect.kind });
             return { state: next, stop: true, executed: effect.kind };
         }
@@ -755,7 +691,7 @@ function runSpawnTrackSupervisor(planRoot, branch, s, protocol, effect, runtime)
         const observed = (0, protocol_1.observeProtocolEffect)(protocol, effect, {
             kind: 'supervisor-observed', trackId, identity: 'expected', readinessNonce: observation.readinessNonce,
         });
-        const next = persist(planRoot, branch, applyProtocolToState(s, observed));
+        const next = (0, track_state_1.persist)(planRoot, branch, (0, track_state_1.applyProtocolToState)(s, observed));
         (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-armed-or-blocked', trackId });
         return { state: next, stop: true, executed: null };
     }
@@ -839,7 +775,7 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
                 for (const track of next.tracks ?? [])
                     if (track.trackId === pendingTeardown.trackId)
                         track.teardownRequested = undefined;
-                s = persist(planRoot, branch, next);
+                s = (0, track_state_1.persist)(planRoot, branch, next);
                 (0, store_1.appendEvent)(planRoot, branch, {
                     kind: 'track-teardown-moot', trackId: pendingTeardown.trackId, phase: s.cohortPhase,
                 });
@@ -847,11 +783,11 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
             }
             const protocolBefore = toProtocol(s, maxParallel);
             const observed = (0, protocol_1.reconcileProtocol)(protocolBefore, { kind: 'teardown-requested', trackId: pendingTeardown.trackId });
-            const next = applyProtocolToState(s, observed);
+            const next = (0, track_state_1.applyProtocolToState)(s, observed);
             for (const track of next.tracks ?? [])
                 if (track.trackId === pendingTeardown.trackId)
                     track.teardownRequested = undefined;
-            s = persist(planRoot, branch, next);
+            s = (0, track_state_1.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.
@@ -886,11 +822,11 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
         if (pendingJoin !== undefined) {
             const protocolBefore = toProtocol(s, maxParallel);
             const observed = (0, protocol_1.reconcileProtocol)(protocolBefore, { kind: 'join-requested', trackId: pendingJoin.trackId });
-            const next = applyProtocolToState(s, observed);
+            const next = (0, track_state_1.applyProtocolToState)(s, observed);
             for (const t of next.tracks ?? [])
                 if (t.trackId === pendingJoin.trackId)
                     t.joinRequested = undefined;
-            s = persist(planRoot, branch, next);
+            s = (0, track_state_1.persist)(planRoot, branch, next);
             (0, store_1.appendEvent)(planRoot, branch, {
                 kind: 'track-join-observed', trackId: pendingJoin.trackId,
                 phase: s.tracks?.find((t) => t.trackId === pendingJoin.trackId)?.phase,
@@ -908,7 +844,7 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
             for (const t of next.tracks ?? [])
                 if (t.trackId === mootJoin.trackId)
                     t.joinRequested = undefined;
-            s = persist(planRoot, branch, next);
+            s = (0, track_state_1.persist)(planRoot, branch, next);
             (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-join-moot', trackId: mootJoin.trackId, phase: mootJoin.phase });
             continue;
         }
@@ -918,7 +854,7 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
             return { state: s, effectExecuted: null };
         if (!RUNTIME_EFFECTS.has(effect.kind)) {
             const applied = (0, protocol_1.observeProtocolEffect)(protocol, effect, { kind: 'effect-applied', effect });
-            const candidate = applyProtocolToState(s, applied);
+            const candidate = (0, track_state_1.applyProtocolToState)(s, applied);
             // Defensivo: un ProtocolEffect sin fase mapeada en `EFFECT_APPLIED_PHASE`
             // (ej. `merge-track`/`request-global-qa`, todavía sin driver propio en
             // esta task — llegan en Tasks 11/12) no debe hacer que este loop gire
@@ -926,7 +862,7 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
             if (candidate.cohortPhase === s.cohortPhase && JSON.stringify(candidate.tracks) === JSON.stringify(s.tracks)) {
                 return { state: s, effectExecuted: null };
             }
-            s = persist(planRoot, branch, candidate);
+            s = (0, track_state_1.persist)(planRoot, branch, candidate);
             const trackId = 'trackId' in effect ? effect.trackId : undefined;
             const label = trackId !== undefined ? (s.tracks?.find((t) => t.trackId === trackId)?.phase ?? effect.kind) : s.cohortPhase;
             // `enter-serial` es el ÚNICO efecto de este branch que lleva una causa: la

package/dist/src/core/admission/index.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_EXECUTION_CAPABILITIES = void 0;
+exports.sanitizeAdmissionReport = sanitizeAdmissionReport;
+exports.admitPlan = admitPlan;
+const providers_1 = require("../../providers");
+const paths_1 = require("../journal/paths");
+const resolve_1 = require("../model-policy/resolve");
+const capabilities_1 = require("../model-policy/capabilities");
+const UNKNOWN = {
+    artifactDelivery: 'unverified', interactiveExecution: 'unverified', unattendedController: 'unverified', nativeSubagents: 'unverified',
+    modelOverride: 'unverified', effortOverride: 'unverified', observedModelEvidence: 'unverified', durableResume: 'unverified',
+};
+/** Deliberate R1 evidence table. Artifact delivery is never used as execution evidence. */
+exports.PROVIDER_EXECUTION_CAPABILITIES = {
+    antigravity: { ...UNKNOWN },
+    opencode: { ...UNKNOWN },
+    'claude-code': { ...UNKNOWN, interactiveExecution: 'supported', unattendedController: 'supported', durableResume: 'supported' },
+    codex: { ...UNKNOWN, interactiveExecution: 'supported', unattendedController: 'supported', durableResume: 'supported' },
+    cursor: { ...UNKNOWN },
+    copilot: { ...UNKNOWN },
+};
+const MAX_DIAGNOSTICS = 20;
+const MAX_DIAGNOSTIC_LENGTH = 4096;
+function safe(value) { return value.replace(/[\u0000-\u001F\u007F-\u009F]/g, character => `\\u${character.codePointAt(0).toString(16).padStart(4, '0')}`).slice(0, MAX_DIAGNOSTIC_LENGTH); }
+function sanitizeDiagnostics(diagnostics) { return diagnostics.slice(0, MAX_DIAGNOSTICS).map(item => ({ code: safe(String(item.code)), message: safe(String(item.message)), ...(typeof item.field === 'string' ? { field: safe(item.field) } : {}) })); }
+function diagnostic(code, message) { return { code: safe(code), message: safe(message) }; }
+function blocked(input, diagnostics, extras = {}) {
+    const { journal = 'not-required', currentness = 'not-checked', sensors = 'not-required', ...rest } = extras;
+    return { state: 'blocked', planState: input.plan.state, journal, currentness, sensors, ...rest, diagnostics: sanitizeDiagnostics(diagnostics) };
+}
+function forecast(slices) {
+    const roles = { implementer: slices, 'specification-reviewer': slices, 'code-quality-reviewer': slices, 'final-reviewer': 1, 'track-a-qa': 1, 'track-b-qa': 1, documentation: 1, retro: 1, finishing: 1 };
+    return { kind: 'topology', slices, roles, total: Object.values(roles).reduce((sum, count) => sum + count, 0) };
+}
+function routingForecast(plan, routing) {
+    const profiles = { mechanical: 0, integration: 0, judgment: 0 };
+    for (const slice of plan.manifest.slices)
+        profiles[slice.implementerProfile] += 1;
+    const qa = routing.qaLens;
+    if (qa !== undefined && (!Array.isArray(qa) || qa.length > 64 || new Set(qa).size !== qa.length || qa.some(id => typeof id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(id))))
+        throw new Error('routing qaLens must be unique validated lens ids');
+    if (routing.controllerCount !== undefined && (!Number.isSafeInteger(routing.controllerCount) || routing.controllerCount < 0 || routing.controllerCount > 1))
+        throw new Error('routing controllerCount must be 0 or 1');
+    return { kind: 'routing-v1', slices: plan.manifest.slices.length, implementerProfiles: profiles, roles: { 'specification-reviewer': plan.manifest.slices.length, 'code-quality-reviewer': plan.manifest.slices.length, 'final-reviewer': 1, 'track-a-qa': 1, documentation: 1, retro: 1, finishing: 1 }, trackB: qa === undefined ? { state: 'unavailable', lowerBound: 1 } : { state: 'known', count: qa.length }, controller: routing.controllerCount === undefined ? { state: 'unavailable', lowerBound: 0 } : { state: 'known', count: routing.controllerCount } };
+}
+function currentness(report, consumedRegistryComponents) {
+    const consumed = new Set(['cli', ...consumedRegistryComponents]);
+    const present = new Set(report.components.map(component => component.component));
+    const missing = [...consumed].filter(component => !present.has(component));
+    if (missing.length > 0)
+        return { status: 'unverifiable', diagnostics: [diagnostic('ADMISSION_CURRENTNESS_MISSING_COMPONENT', `Currentness evidence is missing consumed components: ${missing.join(', ')}.`)] };
+    const failed = report.components.filter(component => consumed.has(component.component) && component.status !== 'current');
+    if (failed.length === 0)
+        return { status: 'current', diagnostics: [] };
+    const names = failed.map(component => component.component).join(', ');
+    const status = failed.some(component => component.status === 'unverifiable') ? 'unverifiable' : 'stale';
+    return { status, diagnostics: [diagnostic('ADMISSION_CURRENTNESS_BLOCKED', `Consumed contract currentness is ${status}: ${names}.`)] };
+}
+function sensorVerdict(report) { return report.overall === 'not_certified' ? 'not-certified' : report.overall === 'pass' ? 'pass' : 'fail'; }
+function journalStatus(input, plan) {
+    if (input.journalCorrupt)
+        return 'corrupt';
+    const journal = input.journalState;
+    if (!journal)
+        return 'missing';
+    if (journal.schema !== 2 || !journal.planBinding)
+        return 'stale';
+    let planPath;
+    try {
+        planPath = (0, paths_1.bindingPlanPath)(input.planPath ?? '');
+    }
+    catch {
+        return 'stale';
+    }
+    const binding = journal.planBinding;
+    return binding.path === planPath && binding.digest === plan.planDigest && binding.schema === plan.schema && binding.executionMode === 'desatendido'
+        ? 'current' : 'stale';
+}
+const PLAN_STATES = new Set(['valid', 'migration-required', 'invalid', 'unsupported']);
+const JOURNALS = new Set(['not-required', 'current', 'missing', 'corrupt', 'stale']);
+const CURRENTNESS = new Set(['current', 'stale', 'unverifiable', 'not-checked']);
+const SENSORS = new Set(['pass', 'fail', 'not-certified', 'not-required']);
+const CAPABILITY = new Set(['supported', 'unsupported', 'unverified']);
+function invalidAdmission() { throw new Error('admission returned an invalid report'); }
+function validCapabilities(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    const keys = ['artifactDelivery', 'interactiveExecution', 'unattendedController', 'nativeSubagents', 'modelOverride', 'effortOverride', 'observedModelEvidence', 'durableResume'];
+    return Object.keys(record).length === keys.length && keys.every(key => CAPABILITY.has(record[key]));
+}
+function validForecast(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    const roles = ['implementer', 'specification-reviewer', 'code-quality-reviewer', 'final-reviewer', 'track-a-qa', 'track-b-qa', 'documentation', 'retro', 'finishing'];
+    const slices = record.slices;
+    const topology = { implementer: slices, 'specification-reviewer': slices, 'code-quality-reviewer': slices, 'final-reviewer': 1, 'track-a-qa': 1, 'track-b-qa': 1, documentation: 1, retro: 1, finishing: 1 };
+    return record.kind === 'topology' && Number.isSafeInteger(slices) && slices >= 0 && Number.isSafeInteger(record.total) && record.total >= 0
+        && !!record.roles && typeof record.roles === 'object' && !Array.isArray(record.roles) && Object.keys(record.roles).length === roles.length
+        && roles.every(role => record.roles[role] === topology[role])
+        && record.total === Object.values(topology).reduce((sum, count) => sum + count, 0);
+}
+function validRoutingForecast(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    const profiles = record.implementerProfiles;
+    const roles = record.roles;
+    const count = (item) => Number.isSafeInteger(item) && item >= 0;
+    const roleKeys = ['specification-reviewer', 'code-quality-reviewer', 'final-reviewer', 'track-a-qa', 'documentation', 'retro', 'finishing'];
+    return record.kind === 'routing-v1' && Object.keys(record).length === 6 && count(record.slices) && !!profiles && Object.keys(profiles).length === 3 && ['mechanical', 'integration', 'judgment'].every(key => count(profiles[key])) && Object.values(profiles).reduce((sum, profile) => sum + profile, 0) === record.slices && !!roles && typeof roles === 'object' && Object.keys(roles).length === roleKeys.length && roleKeys.every(key => key in roles) && roles['specification-reviewer'] === record.slices && roles['code-quality-reviewer'] === record.slices && ['final-reviewer', 'track-a-qa', 'documentation', 'retro', 'finishing'].every(key => roles[key] === 1)
+        && !!record.trackB && typeof record.trackB === 'object' && ((record.trackB.state === 'known' && count(record.trackB.count)) || (record.trackB.state === 'unavailable' && record.trackB.lowerBound === 1))
+        && !!record.controller && typeof record.controller === 'object' && ((record.controller.state === 'known' && count(record.controller.count)) || (record.controller.state === 'unavailable' && record.controller.lowerBound === 0));
+}
+function validDiagnostics(value) {
+    return Array.isArray(value) && value.every(item => item && typeof item === 'object' && typeof item.code === 'string' && typeof item.message === 'string' && (item.field === undefined || typeof item.field === 'string'));
+}
+/** Defensive public-output boundary for injected dependencies as well as core reports. */
+function sanitizeAdmissionReport(report) {
+    if (!report || typeof report !== 'object' || Array.isArray(report))
+        invalidAdmission();
+    const value = report;
+    if ((value.state !== 'admitted' && value.state !== 'blocked') || !PLAN_STATES.has(value.planState) || !JOURNALS.has(value.journal) || !CURRENTNESS.has(value.currentness) || !SENSORS.has(value.sensors) || !validDiagnostics(value.diagnostics))
+        invalidAdmission();
+    if (value.planDigest !== undefined && (typeof value.planDigest !== 'string' || !/^[a-f0-9]{64}$/.test(value.planDigest)))
+        invalidAdmission();
+    if (value.executionMode !== undefined && value.executionMode !== 'interactivo' && value.executionMode !== 'desatendido')
+        invalidAdmission();
+    if (value.provider !== undefined && !(0, providers_1.isAgentTarget)(value.provider))
+        invalidAdmission();
+    if (value.capabilityResolution !== undefined) {
+        const resolution = value.capabilityResolution;
+        if (!resolution || typeof resolution !== 'object' || !['native', 'degraded', 'blocked'].includes(resolution.outcome) || !(0, providers_1.isAgentTarget)(resolution.provider) || !validCapabilities(resolution.capabilities) || resolution.evidenceVersion !== 'r1-v1' || !validDiagnostics(resolution.diagnostics))
+            invalidAdmission();
+    }
+    if (value.forecast !== undefined && !validForecast(value.forecast))
+        invalidAdmission();
+    if (value.routingForecast !== undefined && !validRoutingForecast(value.routingForecast))
+        invalidAdmission();
+    const capabilityResolution = value.capabilityResolution === undefined ? undefined : { ...value.capabilityResolution, diagnostics: sanitizeDiagnostics(value.capabilityResolution.diagnostics) };
+    return { ...value, ...(capabilityResolution ? { capabilityResolution } : {}), diagnostics: sanitizeDiagnostics(value.diagnostics) };
+}
+/** Pure, read-only composition. Callers own every I/O dependency and no dispatch API is exposed here. */
+async function admitPlan(input) {
+    if (!input || typeof input !== 'object' || typeof input.cwd !== 'string' || input.cwd.length === 0)
+        throw new Error('admission requires a cwd');
+    const plan = input.plan;
+    if (!plan || typeof plan !== 'object')
+        throw new Error('admission requires a plan report');
+    if (plan.state !== 'valid') {
+        if (plan.state === 'unsupported')
+            return blocked(input, [diagnostic('ADMISSION_PLAN_UNSUPPORTED', 'This compact plan schema is not supported for admission.'), ...plan.diagnostics]);
+        const code = plan.state === 'migration-required' ? 'ADMISSION_PLAN_MIGRATION_REQUIRED' : 'ADMISSION_PLAN_INVALID';
+        return blocked(input, [diagnostic(code, 'Compact plan validation must succeed before admission.'), ...(plan.state === 'invalid' ? plan.diagnostics : [])]);
+    }
+    if (!(0, providers_1.isAgentTarget)(input.provider))
+        return blocked(input, [diagnostic('ADMISSION_PROVIDER_INVALID', `Unknown provider: ${String(input.provider)}.`)], { planDigest: plan.planDigest });
+    const provider = input.provider;
+    if (input.enabledAgents && !input.enabledAgents.includes(provider)) {
+        return blocked(input, [diagnostic('ADMISSION_PROVIDER_DISABLED', `Provider ${provider} is not enabled.`)], { planDigest: plan.planDigest, provider });
+    }
+    // v1 manifests do not yet carry executionMode in their typed schema. Accept only
+    // the exact future field when an already-validated caller supplies it; otherwise
+    // preserve the safe interactive default until S3 owns durable unattended binding.
+    const manifestMode = plan.manifest.executionMode;
+    const mode = input.executionMode ?? (manifestMode === 'desatendido' ? 'desatendido' : 'interactivo');
+    if (mode !== 'interactivo' && mode !== 'desatendido')
+        return blocked(input, [diagnostic('ADMISSION_EXECUTION_MODE_INVALID', 'Execution mode must be interactivo or desatendido.')], { planDigest: plan.planDigest, provider, executionMode: 'interactivo' });
+    if (input.requireCurrent) {
+        if (input.provenance !== 'proven')
+            return blocked(input, [diagnostic('ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED', 'Consumed registry contracts cannot be proven from validated plan sources.')], { planDigest: plan.planDigest, provider, executionMode: mode, currentness: 'unverifiable' });
+        if (!input.currentness)
+            return blocked(input, [diagnostic('ADMISSION_CURRENTNESS_REQUIRED', 'Currentness evidence was required but not supplied.')], { planDigest: plan.planDigest, provider, executionMode: mode });
+        const gate = currentness(input.currentness, input.consumedRegistryComponents ?? []);
+        if (gate.diagnostics.length)
+            return blocked(input, gate.diagnostics, { planDigest: plan.planDigest, provider, executionMode: mode, currentness: gate.status });
+        if (input.compatibilityDiagnostics?.length)
+            return blocked(input, input.compatibilityDiagnostics, { planDigest: plan.planDigest, provider, executionMode: mode, currentness: 'unverifiable' });
+    }
+    if (input.verifySensors) {
+        if (!input.sensors)
+            return blocked(input, [diagnostic('ADMISSION_SENSORS_REQUIRED', 'Sensor evidence was required but not supplied.')], { planDigest: plan.planDigest, provider, executionMode: mode, currentness: input.requireCurrent ? 'current' : 'not-checked' });
+        const sensors = sensorVerdict(input.sensors);
+        if (sensors !== 'pass')
+            return blocked(input, [diagnostic('ADMISSION_SENSORS_BLOCKED', `Sensor verdict is ${sensors}.`)], { planDigest: plan.planDigest, provider, executionMode: mode, currentness: input.requireCurrent ? 'current' : 'not-checked', sensors });
+    }
+    if (mode === 'desatendido') {
+        const journal = journalStatus(input, plan);
+        if (journal !== 'current')
+            return blocked(input, [diagnostic('ADMISSION_JOURNAL_BINDING_REQUIRED', 'Unattended execution requires a healthy schema-2 journal binding for this exact plan; run watch --init --plan.')], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', sensors: input.verifySensors ? 'pass' : 'not-required' });
+        const capabilities = exports.PROVIDER_EXECUTION_CAPABILITIES[provider];
+        const resolution = { outcome: capabilities.unattendedController === 'supported' ? 'native' : 'blocked', provider, capabilities, evidenceVersion: 'r1-v1', diagnostics: [] };
+        if (resolution.outcome === 'blocked')
+            return blocked(input, [diagnostic('ADMISSION_CAPABILITY_UNVERIFIED', `Provider ${provider} has no verified unattended execution capability.`)], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', sensors: input.verifySensors ? 'pass' : 'not-required', capabilityResolution: resolution });
+        return completeAdmission(input, plan, provider, mode, journal, input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution);
+    }
+    const capabilities = exports.PROVIDER_EXECUTION_CAPABILITIES[provider];
+    const resolution = { outcome: capabilities.interactiveExecution === 'supported' ? 'native' : 'blocked', provider, capabilities, evidenceVersion: 'r1-v1', diagnostics: [] };
+    if (resolution.outcome === 'blocked')
+        return blocked(input, [diagnostic('ADMISSION_CAPABILITY_UNVERIFIED', `Provider ${provider} has no verified interactive execution capability.`)], { planDigest: plan.planDigest, provider, executionMode: mode, capabilityResolution: resolution });
+    return completeAdmission(input, plan, provider, mode, 'not-required', input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution);
+}
+function completeAdmission(input, plan, provider, executionMode, journal, currentness, sensors, capabilityResolution) {
+    if (plan.schema === 'compact-slices/v1')
+        return { state: 'admitted', planState: 'valid', planDigest: plan.planDigest, provider, executionMode, journal, currentness, sensors, capabilityResolution, forecast: forecast(plan.manifest.slices.length), diagnostics: [] };
+    const routing = input.routing ?? input.routingReader?.();
+    if (!routing?.runtime || !routing.policy || !routing.capabilities)
+        return blocked(input, [diagnostic('ADMISSION_ROUTING_FACTS_REQUIRED', 'Compact v2 requires an approved policy, current capability receipt, and runtime identity.')], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, sensors, capabilityResolution });
+    let runtime;
+    try {
+        runtime = (0, capabilities_1.validateRuntimeKey)(routing.runtime);
+    }
+    catch {
+        return blocked(input, [diagnostic('ADMISSION_ROUTING_RUNTIME_INVALID', 'Compact v2 routing runtime identity is invalid.')], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, sensors, capabilityResolution });
+    }
+    if (runtime.target !== provider)
+        return blocked(input, [diagnostic('ADMISSION_ROUTING_PROVIDER_MISMATCH', 'Compact v2 routing runtime target must exactly match the admitted provider.')], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, sensors, capabilityResolution });
+    const now = routing.now ?? new Date();
+    for (const slice of plan.manifest.slices) {
+        const resolved = (0, resolve_1.resolveSelection)({ role: 'implementer', requestedProfile: slice.implementerProfile, policy: routing.policy, capabilities: routing.capabilities, runtime, now });
+        if (resolved.state === 'blocked')
+            return blocked(input, resolved.diagnostics, { planDigest: plan.planDigest, provider, executionMode, journal, currentness, sensors, capabilityResolution });
+    }
+    return { state: 'admitted', planState: 'valid', planDigest: plan.planDigest, provider, executionMode, journal, currentness, sensors, capabilityResolution, forecast: forecast(plan.manifest.slices.length), routingForecast: routingForecast(plan, routing), diagnostics: [] };
+}
+// Structural exhaustiveness guard: adding an AgentTarget requires an explicit entry above.
+const capabilityTargets = providers_1.AGENT_TARGETS;
+if (Object.keys(exports.PROVIDER_EXECUTION_CAPABILITIES).length !== capabilityTargets.length || !capabilityTargets.every(target => target in exports.PROVIDER_EXECUTION_CAPABILITIES))
+    throw new Error('provider capability table must be exhaustive');