agentic-workflow-manager 6.2.0 → 6.3.0

package/dist/src/commands/track/supervisor-wrapper.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSupervisorWrapper = runSupervisorWrapper;
+// Wrapper detached del supervisor de UN track (Step 5, R4.7-R4.10, C11):
+// mismo contrato de durabilidad que `job/exec-wrapper.ts` (claim exclusivo ->
+// identidad -> resultado), adaptado a "arrancar un supervisor" en vez de "un
+// comando". Claim con `wx`: un segundo wrapper lanzado con el mismo intent
+// jamás lanza un segundo supervisor — solo detecta el claim y sale.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const child_process_2 = require("child_process");
+const process_1 = require("../../core/journal/process");
+const atomic_file_1 = require("../../core/atomic-file");
+const store_1 = require("../../core/journal/store");
+const paths_1 = require("../../core/journal/paths");
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function localBranch(worktreePath) {
+    return (0, child_process_2.execFileSync)('git', ['branch', '--show-current'], { cwd: worktreePath, encoding: 'utf8', stdio: process_1.EXEC_STDIO }).trim();
+}
+function defaultLaunchWatch(worktreePath) {
+    const cliEntry = path_1.default.resolve(__dirname, '..', '..', 'index.js');
+    const child = (0, child_process_1.spawn)(process.execPath, [cliEntry, 'watch'], { cwd: worktreePath, detached: true, stdio: 'ignore' });
+    child.unref();
+}
+/**
+ * Ejecuta el ciclo de vida completo del wrapper: claim exact-once -> identity
+ * sidecar -> init del journal local (idempotente, ya lo creó el supervisor
+ * del plan) -> readiness sidecar -> espera read-only al propio TrackRef del
+ * plan -> al pasar a ACTIVE, lanza `awm watch` y espera a que el lock quede
+ * adquirido. Mientras espera slot, NO corre gate, fingerprint ni tareas.
+ */
+async function runSupervisorWrapper(opts) {
+    const dir = path_1.default.join(opts.worktreePath, '.awm');
+    fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const claimPath = path_1.default.join(dir, 'supervisor.claim');
+    let fd;
+    try {
+        fd = fs_1.default.openSync(claimPath, 'wx', 0o600);
+    }
+    catch {
+        return 'already-claimed';
+    }
+    const nonce = opts.nonce;
+    try {
+        fs_1.default.writeFileSync(fd, JSON.stringify({ trackId: opts.trackId, nonce, claimedAt: new Date().toISOString(), pid: process.pid }) + '\n');
+        fs_1.default.fsyncSync(fd);
+    }
+    finally {
+        fs_1.default.closeSync(fd);
+    }
+    (0, atomic_file_1.fsyncDirSync)(dir);
+    (0, atomic_file_1.writeFileAtomicDurable)(path_1.default.join(dir, 'supervisor.identity.json'), JSON.stringify({ trackId: opts.trackId, nonce, self: (0, process_1.captureSelfRef)(nonce) }, null, 2) + '\n', 0o600);
+    // Idempotente: el supervisor del plan ya corrió `initTrackJournal` antes
+    // de spawnear este wrapper — esto solo defiende contra el caso en que
+    // ese paso quedó a medias (nunca sobreescribe: `initJournal` no toca un
+    // state.json ya existente).
+    (0, store_1.initJournal)(opts.worktreePath, localBranch(opts.worktreePath));
+    (0, atomic_file_1.writeFileAtomicDurable)(path_1.default.join(dir, 'supervisor.ready.json'), JSON.stringify({ readinessNonce: opts.readinessNonce, at: new Date().toISOString() }, null, 2) + '\n', 0o600);
+    const sleep = opts.sleep ?? defaultSleep;
+    const pollMs = opts.pollMs ?? 2000;
+    const maxIterations = opts.maxWaitIterations ?? Number.POSITIVE_INFINITY;
+    for (let i = 0; i < maxIterations; i++) {
+        const r = (0, store_1.readJournal)(opts.planRoot, opts.planBranch);
+        if (!r.corrupt && r.state !== null) {
+            const ref = r.state.tracks?.find((t) => t.trackId === opts.trackId);
+            if (ref?.phase === 'ACTIVE')
+                break;
+            // BLOCKED/REMOVED: el plan ya decidió que este track no avanza —
+            // el wrapper nunca lanza `awm watch` para un track que el plan
+            // bloqueó, ni insiste indefinidamente (C1: la barrera es del plan).
+            if (ref?.phase === 'BLOCKED' || ref?.phase === 'REMOVED')
+                return 'blocked';
+        }
+        if (i === maxIterations - 1)
+            return 'blocked';
+        await sleep(pollMs);
+    }
+    const launch = opts.launchWatch ?? defaultLaunchWatch;
+    launch(opts.worktreePath);
+    const lockPath = (0, paths_1.supervisorLockPath)(opts.worktreePath);
+    for (let i = 0; i < (opts.maxWaitIterations ?? 50) && !fs_1.default.existsSync(lockPath); i++) {
+        await sleep(Math.min(pollMs, 100));
+    }
+    return 'active';
+}

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

@@ -3,19 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCyclePlanAppend = applyCyclePlanAppend;
+exports.registerTrackIntegrationItems = registerTrackIntegrationItems;
 exports.consumePendingRequests = consumePendingRequests;
 // Consumo transaccional de requests (bloqueador 4): mutar estado ->
 // writeJournal -> RECIEN AHI borrar archivos. El replay es seguro por
 // requestId + idempotencyKey + digest.
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
 const store_1 = require("../../core/journal/store");
 const requests_1 = require("../../core/journal/requests");
 const paths_1 = require("../../core/journal/paths");
 const atomic_file_1 = require("../../core/atomic-file");
 const redact_1 = require("../../core/journal/redact");
+const git_1 = require("../../core/tracks/git");
 function now() { return new Date().toISOString(); }
-const VERIFICATION_KINDS = ['test', 'lint', 'sensors', 'review', 'qa', 'interlock'];
+const VERIFICATION_KINDS = ['test', 'lint', 'sensors', 'review', 'qa', 'interlock', 'track-integration'];
 function verificationItems(value, field) {
     if (!Array.isArray(value) || !value.every((item) => typeof item === 'object' && item !== null
         && typeof item.id === 'string'
@@ -38,6 +42,22 @@ function stringArray(value, field) {
         throw new Error(`${field} requiere array de strings`);
     return value;
 }
+/** R7 Task 12: `job-request.satisfies` migró de string a array (un mismo job
+ *  puede satisfacer VARIOS items del ciclo a la vez — ej. el job canónico de
+ *  integración final satisface todos los `track-integration:*` juntos).
+ *  Acepta AMBAS formas en el payload (string legacy o array) — el emisor
+ *  actual (`requestJob`) siempre manda array, pero una request en vuelo
+ *  emitida por un binario anterior al deploy de este cambio no debe
+ *  rechazarse por forma. */
+function satisfiesArray(value, field) {
+    if (value === undefined)
+        return [];
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    throw new Error(`${field} requiere string o array de strings`);
+}
 function linkSatisfies(s, itemId, jobId) {
     const items = [...s.tasks.flatMap((t) => t.verificationPlan), ...s.cycleVerificationPlan];
     const item = items.find((i) => i.id === itemId);
@@ -45,7 +65,45 @@ function linkSatisfies(s, itemId, jobId) {
         throw new Error(`VerificationItem desconocido: ${itemId}`);
     item.satisfiedBy = jobId;
 }
-function applyRequestToState(s, env, digest) {
+/** R7.2 (Task 12): append transaccional — agrega items NUEVOS por id sin
+ *  jamás pisar un item ya existente (preserva `satisfiedBy` ya enlazado). Una
+ *  colisión de `kind` para el mismo id rechaza el request COMPLETO (se llama
+ *  siempre sobre el clone transaccional de `consumePendingRequests`, así que
+ *  un throw acá descarta la mutación entera vía el catch de ese loop). */
+function applyCyclePlanAppend(state, incoming) {
+    const byId = new Map(state.cycleVerificationPlan.map((item) => [item.id, item]));
+    for (const item of incoming) {
+        const prior = byId.get(item.id);
+        if (prior !== undefined && prior.kind !== item.kind)
+            throw new Error(`verification item ${item.id} cambia kind`);
+        if (prior === undefined)
+            byId.set(item.id, { ...item });
+    }
+    state.cycleVerificationPlan = [...byId.values()];
+}
+/** R7.3 (Task 12): declarar un track dentro de la cohorte agrega DE INMEDIATO
+ *  su `track-integration:<trackId>` al CycleVerificationPlan, sin
+ *  `satisfiedBy` — el gate global queda rojo desde el momento en que la
+ *  cohorte se conoce, nunca solo al final. Idempotente por construcción
+ *  (`applyCyclePlanAppend`): llamarla de nuevo con el mismo conjunto de
+ *  tracks es un no-op para los ids ya presentes. */
+function registerTrackIntegrationItems(state) {
+    const items = [...new Set((state.tracks ?? []).map((t) => t.trackId))].sort()
+        .map((trackId) => ({ id: `track-integration:${trackId}`, kind: 'track-integration' }));
+    applyCyclePlanAppend(state, items);
+}
+/** Convención determinista, sibling del repo del plan — nunca DENTRO de su
+ *  working tree (git worktree add lo exige, y evita que el track pise el
+ *  árbol que el propio plan está observando). El trackId ya pasó
+ *  `gitCheckTrackId` antes de llegar acá, así que es seguro como segmento
+ *  de path. NOTA (ver `concerns` del reporte de Task 8): esta función NO
+ *  deriva ownership/dependsOn/sharedResources del plan — `reconcileTracks`
+ *  (P1) no los necesita; quedan en `[]` hasta que un mecanismo futuro (fuera
+ *  de alcance de R5-T8) los declare explícitamente. */
+function trackWorktreePath(repoRoot, trackId) {
+    return path_1.default.join(path_1.default.dirname(repoRoot), `${path_1.default.basename(repoRoot)}.track-${trackId}`);
+}
+function applyRequestToState(s, env, digest, repoRoot) {
     const base = { requestId: env.requestId, idempotencyKey: env.idempotencyKey, payloadDigest: digest };
     if (env.kind === 'controller-heartbeat') {
         s.controllerHeartbeatAt = now();
@@ -71,12 +129,13 @@ function applyRequestToState(s, env, digest) {
             && (['received', 'spawn-intent', 'claimed', 'running'].includes(j.executionState)
                 || (j.executionState === 'exited' && j.verdict === 'pass')));
         if (equivalent !== undefined) {
-            if (typeof p.satisfies === 'string')
-                linkSatisfies(s, p.satisfies, equivalent.id);
+            for (const itemId of satisfiesArray(p.satisfies, 'job-request satisfies'))
+                linkSatisfies(s, itemId, equivalent.id);
             (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: equivalent.id });
             return;
         }
         const jobId = `job-${Object.keys(s.jobs).length + 1}-${crypto_1.default.randomBytes(3).toString('hex')}`;
+        const satisfiesIds = satisfiesArray(p.satisfies, 'job-request satisfies');
         const job = {
             id: jobId,
             fingerprint: String(p.fingerprint), commandDigest: String(p.commandDigest),
@@ -86,14 +145,122 @@ function applyRequestToState(s, env, digest) {
             expandedPaths: p.expandedPaths === undefined ? [] : stringArray(p.expandedPaths, 'job-request expandedPaths'),
             executionState: 'received', observationState: 'progressing',
             phaseTimestamps: { received: now() },
-            ...(typeof p.satisfies === 'string' ? { satisfies: p.satisfies } : {}),
+            ...(satisfiesIds.length > 0 ? { satisfies: satisfiesIds } : {}),
         };
         s.jobs[jobId] = job;
-        if (typeof p.satisfies === 'string')
-            linkSatisfies(s, p.satisfies, jobId);
+        for (const itemId of satisfiesIds)
+            linkSatisfies(s, itemId, jobId);
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: jobId });
         return;
     }
+    if (env.kind === 'track-prepare-request') {
+        // R4.1/R6.1: el ÚNICO efecto de esta request es declarar el TrackRef
+        // (fase DECLARED) — todo lo que sigue (worktree, journal, supervisor,
+        // ARMED, ACTIVE) es propiedad exclusiva de `reconcileTracks`
+        // (watch/tracks.ts), nunca de este consumo transaccional.
+        //
+        // ============================================================
+        // GAP CONOCIDO Y DELIBERADAMENTE DIFERIDO (post-review Task 8,
+        // item 3 — decisión: opción (b), NO implementar acá):
+        //
+        // `TrackContext.taskIds`/`planDigest` (asignados en
+        // `tracks.ts::runCreateTrackJournal`) y `TrackRef.ownership`/
+        // `dependsOn`/`sharedResources` (asignados acá abajo) quedan
+        // `[]`/`''` — NINGÚN task de 1 a 8 provee un mecanismo para que el
+        // supervisor localice y parsee "el" archivo de plan .md de la rama
+        // en ejecución. `parseTrackPlan` HOY solo se invoca desde
+        // `track verify-independence --plan <file>`, con el path pasado a
+        // mano; no existe convención de descubrimiento automático
+        // (ni glob de `docs/plans/*.md`, ni mapeo rama->archivo).
+        //
+        // Esto NO bloquea a Task 8 (el protocolo P1 de `nextProtocolEffect`
+        // jamás lee estos campos), pero SÍ va a romper en silencio:
+        //   - Task 5's `assertTrackTask`/`computeTrackGate` (gating por
+        //     `taskIds`/`planDigest` reales) una vez que algo intente usarlos
+        //     de verdad contra un track creado por esta vía.
+        //   - El supuesto de Task 14 (`docs/plans/2026-08-02-r5-parallel-
+        //     tracks-plan.md:2587-2591`) de que `trackContext.taskIds` ya es
+        //     confiable para ese momento.
+        //
+        // Requiere una decisión humana sobre qué task es dueño de: (a)
+        // definir la convención de descubrimiento del archivo de plan, y
+        // (b) extender `track add`/`emitTrackRequest` para llevarlo — o una
+        // enmienda al plan de 17 tasks. No se improvisa acá.
+        // ============================================================
+        const p = env.payload;
+        if (typeof p.trackId !== 'string' || p.trackId.length === 0)
+            throw new Error('track-prepare-request requiere trackId');
+        const trackId = p.trackId;
+        if (!(0, git_1.gitCheckTrackId)(trackId))
+            throw new Error(`track-prepare-request: trackId inválido: ${trackId}`);
+        if (!s.tracks?.some((t) => t.trackId === trackId)) {
+            const ref = {
+                trackId,
+                worktreePath: trackWorktreePath(repoRoot, trackId),
+                branch: `awm-track/${trackId}`,
+                ownership: [], sharedResources: [], dependsOn: [], // ver GAP arriba
+                // R4.10: tokens criptográficamente aleatorios — los hashes
+                // deterministas de protocol.ts son solo valores opacos del
+                // modelo puro, jamás la fuente real de un token de producción.
+                fencingToken: crypto_1.default.randomBytes(32).toString('hex'),
+                phase: 'DECLARED',
+                readinessNonce: crypto_1.default.randomBytes(32).toString('hex'),
+            };
+            s.tracks = [...(s.tracks ?? []), ref];
+            // R7.3 (Task 12): el gate global queda rojo desde el momento en
+            // que un track se conoce — no espera a que la cohorte termine de
+            // declararse ni a JOINING/FINAL_QA.
+            registerTrackIntegrationItems(s);
+            // C1: la barrera ARMED solo tiene sentido con el conjunto COMPLETO
+            // de la cohorte conocido — recién con >= 2 tracks declarados
+            // existe algo que `reconcileTracks` pueda reconciliar (Task 1
+            // exige al menos dos tracks en cualquier CohortProtocol válido).
+            if (s.tracks.length >= 2 && s.cohortPhase === undefined) {
+                s.cohortPhase = 'PREPARING';
+                s.cohortBaseSha = (0, git_1.headSha)(repoRoot);
+            }
+        }
+        (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
+        // journal (el journal de UN track), vía el mismo primitivo durable
+        // (`emitRequest`) que cualquier otra request. El propio supervisor
+        // del track (SU `Supervisor.tick()`, corriendo en este mismo
+        // worktree) la consume acá como cualquier otra — el efecto es
+        // puramente declarativo (marcar la intención); las 6 observaciones
+        // reales (drenar jobs, recomputar gate, exigir árbol limpio,
+        // terminar la generación propia) las hace `Supervisor.tick()` en su
+        // propio loop, nunca este consumo transaccional (que no puede
+        // esperar terminaciones de proceso reales). Idempotente sin
+        // importar cuántas veces se re-emita, y jamás pisa un `frozen` ya
+        // persistido (R6.4: un track congelado no vuelve a mutar).
+        if (s.frozen === undefined)
+            s.freezeRequested = true;
+        (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied' });
+        return;
+    }
+    if (env.kind === 'track-finalize-request') {
+        // R7.2 (Task 12): a diferencia de `track-freeze-request` (cross-
+        // journal, un track por cada uno), esta request es PLAN-scoped — el
+        // propio controller del PLAN (corriendo `post-implementation-qa`
+        // sobre el HEAD ya mergeado de todos los tracks) la emite a SU PROPIO
+        // journal para reportar "ya corregí hallazgos y comiteé, este es mi
+        // HEAD limpio". El efecto acá es puramente declarativo (autoreporte);
+        // `reconcileTracks`/`runRequestGlobalQa` (watch/tracks.ts) es quien
+        // hace las dos observaciones reales independientes (HEAD real
+        // coincide, árbol/índice limpios) antes de aceptarlo como evidencia
+        // de `global-qa-pass` — jamás se confía ciegamente en el autoreporte
+        // (mismo criterio fail-closed que el freeze de un track, Task 10).
+        const p = env.payload;
+        if (typeof p.qaHeadSha !== 'string' || p.qaHeadSha.length === 0)
+            throw new Error('track-finalize-request requiere qaHeadSha');
+        s.qaFinalizeRequested = { headSha: p.qaHeadSha, at: now() };
+        (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied' });
+        return;
+    }
     if (env.kind === 'register-entity') {
         const p = env.payload;
         if (p.entity === 'task') {
@@ -119,11 +286,32 @@ function applyRequestToState(s, env, digest) {
         }
         if (p.entity === 'cycle-plan') {
             const items = verificationItems(p.items, 'register --entity cycle-plan items');
-            // Idempotente por creacion-unica (Task 4): un re-registro defensivo
-            // (ej. tras crash sin memoria de si ya se registro) NUNCA debe pisar
-            // un plan ya existente y perder los `satisfiedBy` ya enlazados.
-            if (s.cycleVerificationPlan.length === 0) {
-                s.cycleVerificationPlan = items;
+            // R7.2 (Task 12): append transaccional por id — reemplaza el guard
+            // "solo si vacío" (Fix4/R1.4b original). Un re-registro defensivo
+            // (ej. tras crash sin memoria de si ya se registro) NUNCA pisa un
+            // item ya existente ni pierde su `satisfiedBy`, pero SÍ agrega los
+            // ids nuevos (ej. `track-integration:*` que `registerTrackIntegrationItems`
+            // fue agregando en paralelo) — el plan de ciclo crece por unión,
+            // nunca se reemplaza entero.
+            applyCyclePlanAppend(s, items);
+            (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied' });
+            return;
+        }
+        if (p.entity === 'track-integration') {
+            // R7/C3/C4 (Task 12): el contrato canónico ÚNICO del job de
+            // integración final de la cohorte — creación-única (como
+            // cycle-plan antes de R7.2): jamás se pisa un contrato ya
+            // registrado, porque dos contratos distintos en el tiempo
+            // producirían dos idempotencyKeys distintas para "la" integración
+            // final (violaría C4 — un solo job canónico).
+            const argv = stringArray(p.argv, 'register --entity track-integration argv');
+            if (argv.length === 0)
+                throw new Error('register --entity track-integration requiere argv no vacio');
+            const paths = p.paths === undefined ? [] : stringArray(p.paths, 'register --entity track-integration paths');
+            if (typeof p.planDigest !== 'string')
+                throw new Error('register --entity track-integration requiere planDigest (string)');
+            if (s.trackIntegration === undefined) {
+                s.trackIntegration = { argv, paths, planDigest: p.planDigest };
             }
             (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied' });
             return;
@@ -317,7 +505,7 @@ function consumePendingRequests(repoRoot, branch, activeToken) {
                 // nunca deja un estado parcialmente contaminado que luego no se
                 // pueda serializar o reintentar.
                 const candidate = structuredClone(s);
-                applyRequestToState(candidate, env, digest);
+                applyRequestToState(candidate, env, digest, repoRoot);
                 s = candidate;
                 applied++;
                 stateTouched = true;

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

@@ -6,6 +6,8 @@ const init_1 = require("./init");
 const supervisor_1 = require("./supervisor");
 const process_1 = require("../../core/journal/process");
 const adapter_1 = require("../../core/journal/adapter");
+const context_1 = require("../../core/tracks/context");
+const concurrency_1 = require("../../core/tracks/concurrency");
 function currentBranch(cwd) {
     // stdio explicito (ver EXEC_STDIO en journal/process.ts): evita el relay
     // default de execFileSync del stderr de git hacia el stderr del llamante,
@@ -29,9 +31,20 @@ function registerWatchCommand(program) {
         .option('--provider <p>', adapter_1.WATCH_PROVIDERS.join(' | '), 'codex')
         .option('--heartbeat-timeout <min>', 'minutos de silencio de heartbeat', '5')
         .option('--activity-window <min>', 'minutos extra sin actividad de proceso', '10')
+        .option('--max-parallel <n>', 'tope de tracks ACTIVE simultáneos (default: derivado del benchmark empaquetado)')
         .action(async (opts) => {
         const repo = process.cwd();
         const branch = currentBranch(repo);
+        // R9.4: sin descriptor de track, no-op (modo plan de siempre); con
+        // descriptor presente que no autentica, rechaza ANTES de tocar el
+        // journal — mismo patron de salida que el resto de `awm job`.
+        try {
+            (0, context_1.resolveCommandContext)(repo, branch);
+        }
+        catch (e) {
+            process.stderr.write(`${e.message}\n`);
+            process.exit(1);
+        }
         if (opts.init) {
             const out = (0, init_1.initWatch)(repo, branch);
             process.stdout.write(`journal inicializado para ${branch}; verificadores requeridos: ${JSON.stringify(out.requiredVerifiers)}\n`);
@@ -51,6 +64,7 @@ function registerWatchCommand(program) {
             provider: opts.provider,
             heartbeatTimeoutMs: minutes('--heartbeat-timeout', opts.heartbeatTimeout),
             activityWindowMs: minutes('--activity-window', opts.activityWindow),
+            maxParallelTracks: opts.maxParallel !== undefined ? (0, concurrency_1.parseMaxParallel)(opts.maxParallel) : (0, concurrency_1.loadDefaultParallelism)(),
         };
         process.stdout.write(`awm watch: supervisor activo (${cfg.provider}) — Ctrl-C para terminar\n`);
         await (0, supervisor_1.runSupervisorLoop)(repo, branch, cfg);

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

@@ -169,12 +169,31 @@ function collectAndReconcile(repoRoot, branch, opts = {}) {
     }
     return { advanced, decisions: out.decisions };
 }
+/** `dispatch:false` (R5.2/R6.3, Task 10 — "el supervisor del track deja de
+ *  despachar" durante un freeze): el drenaje de jobs YA vivos sigue intacto
+ *  (`collectAndReconcile` siempre corre, y un job `spawn-intent` sin claim
+ *  aun se reintenta con el MISMO intent — la reconciliacion de
+ *  `retry-same-intent` de abajo NUNCA se gatea por `dispatch`, corre
+ *  siempre, freeze o no: es exactamente lo que permite que un job cuyo
+ *  wrapper murio justo al pedirse el freeze siga avanzando hacia un estado
+ *  terminal en vez de quedar varado en `spawn-intent` para siempre — sin
+ *  esto, `liveJobs` jamas llegaria a cero y `attemptFreeze` jamas
+ *  convergeria, R6.3), pero jamás se arranca un job GENUINAMENTE nuevo
+ *  (`spawnPendingWrappers` para `received`) mientras el freeze está en
+ *  curso — eso sí queda gateado por `dispatch`. Default `true`: ningún
+ *  caller existente (loop normal del supervisor) cambia de comportamiento. */
 function runnerTick(repoRoot, branch, spawner, opts = {}) {
+    const dispatch = opts.dispatch ?? true;
     const collected = collectAndReconcile(repoRoot, branch, opts);
     const r = (0, store_1.readJournal)(repoRoot, branch);
     if (r.corrupt || r.state === null)
         throw new Error('journal corrupto: el supervisor no opera sobre corrupcion (R1.6)');
     const logs = (0, paths_1.logsDir)(repoRoot, branch);
+    // Reintento de intent YA vivo (nunca trabajo nuevo): un job en
+    // `spawn-intent` sin claim es, por definicion, un intent que YA se
+    // habia decidido antes del freeze — reemitir el MISMO spawn es
+    // progresar/drenar ese job, no arrancar algo nuevo. Corre SIEMPRE,
+    // incluso con `dispatch:false`.
     for (const decision of collected.decisions) {
         if (decision.action !== 'retry-same-intent')
             continue;
@@ -186,6 +205,6 @@ function runnerTick(repoRoot, branch, spawner, opts = {}) {
         }
         catch { /* el mismo intent durable se reintentara en otro tick */ }
     }
-    const spawned = spawnPendingWrappers(repoRoot, branch, spawner);
+    const spawned = dispatch ? spawnPendingWrappers(repoRoot, branch, spawner) : 0;
     return { spawned, advanced: collected.advanced, decisions: collected.decisions };
 }