@tacuchi/agent-workflow-cli 25.7.0 → 25.9.0

package/dist/domain/flow/authority.js

@@ -43,6 +43,10 @@ export function proposalContractOf(decision) {
 export function publishApprovalOf(decision) {
     return decision.publishes?.approve ?? null;
 }
+/** The redraft alternative of a confirmation row and where it re-enters, or `null`. */
+export function reentryOf(decision) {
+    return decision.reenters ?? null;
+}
 /** Whether this row's answer is what fixes the run's plan and its sources. */
 export function scopesSources(decision) {
     return decision.scopes_sources === true;
@@ -139,6 +143,7 @@ export const INTERNAL_ACTION_OPERATIONS = [
     "proposal.publish",
     /** Seal the next plan-execution batch before any of its work is credited. */
     "plan-exec.batch-infer",
+    "plan-exec.batch-commit",
     /** Close one sealed plan-execution batch through the document/state CAS. */
     "plan-exec.batch-close",
     /** Seal a fully evidenced PLAN-exec document as done. */
@@ -164,13 +169,14 @@ export const INTERNAL_OPERATION_EFFECTS = {
     // it replaces nothing and it destroys nothing. That the CLI reaches git to make
     // it is not what the class measures — `workspace.board` already reads git the
     // same way and is `read_only`.
-    "worktree.ensure": ["local_additive"],
+    "worktree.ensure": ["local_additive", "mutate_overwrite"],
     // Creating and replacing, both real — and which of the two happens is decided
     // by the proposal, not by the row: what the row declares here is the ceiling.
     "proposal.publish": ["local_additive", "mutate_overwrite"],
     // Inference writes only the run's sealed ledger. It changes no project
     // artifact and therefore has no capability-world effect to authorize.
     "plan-exec.batch-infer": [],
+    "plan-exec.batch-commit": ["execute", "local_additive"],
     // Batch progress always rewrites the current plan document, but only from the
     // exact before/after pair persisted in its v10 batch state.
     "plan-exec.batch-close": ["mutate_overwrite"],
@@ -451,14 +457,17 @@ const ROUTE_VALIDATION = {
     },
     risk: "la ausencia o sustitución de evidencia reduce el assurance del cierre",
 };
-const ROUTE_REVIEW = {
+/**
+ * The phase validation of `plan-exec`: substitutable, never omissible. Omitting it
+ * would credit a batch with no proof of its own checkout at all.
+ */
+const ROUTE_PHASE_VALIDATION = {
     recommendation: "apply",
     consequences: {
-        apply: "se revisan los hallazgos del cambio antes de continuar",
-        omit: "se continúa sin esa revisión y queda el riesgo aceptado",
-        substitute: "se usa la revisión o inspección sustituta declarada",
+        apply: ROUTE_VALIDATION.consequences.apply,
+        substitute: ROUTE_VALIDATION.consequences.substitute,
     },
-    risk: "un cambio sin revisión puede conservar defectos o deuda innecesaria",
+    risk: ROUTE_VALIDATION.risk,
 };
 /** The five signals of the multi-plan split gate, shared by both plan loops. */
 const PLAN_SPLIT_SIGNALS = [
@@ -713,6 +722,42 @@ export const FLOW_DECISIONS = [
             symbol: "flowControlChoices",
         },
     },
+    {
+        id: "chassis.commit-choice",
+        scope: CHASSIS,
+        title: "aprobar el commit del workspace por rutas explícitas o cerrar sin él",
+        authority: "human",
+        ownership: "cli-owned",
+        document: CHASSIS_MD,
+        attribution: CHASSIS_ATTRIBUTION,
+        placement: "suffix",
+        alternatives: [
+            {
+                label: "Cerrar sin commit",
+                consequence: "se archiva el mínimo y se cierra la sesión; el trabajo del workspace queda sin commitear",
+                recommended: true,
+                outcome: { kind: "continue" },
+            },
+            {
+                label: "Aprobar commit del workspace",
+                consequence: "se cierra y luego el CLI commitea solamente el pathspec y mensaje mostrados en la propuesta; nunca hace push",
+                recommended: false,
+                outcome: { kind: "continue" },
+            },
+            {
+                label: "Copiar evidencia y cerrar",
+                consequence: "se copian a la sesión las referencias existentes del scratchpad y se archivan antes de cerrar, sin commit",
+                recommended: false,
+                outcome: { kind: "continue" },
+            },
+            {
+                label: "Copiar evidencia y aprobar commit del workspace",
+                consequence: "se copia la evidencia efímera a la sesión, se archiva y entra en el commit aprobado del cierre; nunca hace push",
+                recommended: false,
+                outcome: { kind: "continue" },
+            },
+        ],
+    },
     {
         id: "chassis.finalize",
         scope: CHASSIS,
@@ -743,7 +788,7 @@ export const FLOW_DECISIONS = [
             execution: { kind: "internal", operation: "session.close" },
             evidence: ["chassis.sesion-cerrada"],
             idempotent: true,
-            recovery: "una sesión que no cerró deja la corrida abierta: no la marques finalizada — reparás la fila del registro con 'aw history-update' y volvés a cerrar",
+            recovery: "una sesión que no cerró deja la corrida abierta: no la marques finalizada — reparás la fila del registro con 'aw history-update' y volvés a cerrar; si el cierre lo empezó 'aw session-close', volvé a correrlo: termina la corrida en su frontera conservando las unidades",
         },
     },
     // ── QUICK — the pilot tranche, and the first one this CLI decides ──────────
@@ -830,9 +875,9 @@ export const FLOW_DECISIONS = [
         alternatives: [
             {
                 label: "Cambiar a SPEC",
-                consequence: "no se crea sesión quick: la línea de trabajo pasa al flow SPEC con el objetivo original",
+                consequence: "se cierra la sesión quick conservando lo pendiente y se entrega el pedido a /w:spec-new",
                 recommended: true,
-                outcome: { kind: "continue" },
+                outcome: { kind: "handoff", destination: "spec-new" },
             },
             {
                 label: "Seguir en quick",
@@ -928,7 +973,7 @@ export const FLOW_DECISIONS = [
                 "quick.checkpoint-sembrado",
             ],
             idempotent: true,
-            recovery: "sembrá lo que falte (objetivo, criterios de éxito y CHECKPOINT.Pending) y volvé a devolver el dump: sembrar de nuevo lo ya escrito no rompe nada",
+            recovery: "completá el objetivo y los criterios de éxito y corré aw flow advance: el CLI siembra el CHECKPOINT que falta sin reemplazar lo escrito",
         },
     },
     {
@@ -942,7 +987,12 @@ export const FLOW_DECISIONS = [
         // Same read as PLAN's, and for the same reason: `aw check-branch` with no
         // --source resolves no target and passes unconditionally.
         action: {
-            invocation: { program: "aw", args: ["sources", "--verbose"], target: ".", input: null },
+            invocation: {
+                program: "aw",
+                args: ["sources", "--verbose", "--code", "{code}"],
+                target: ".",
+                input: null,
+            },
             execution: {
                 kind: "external",
                 reason: "la rama esperada de cada fuente es un veredicto sobre git, y un workspace sin fuentes declaradas no lo tiene: leerlo desde adentro diría 'verificada' donde no hay nada que verificar",
@@ -1027,12 +1077,12 @@ export const FLOW_DECISIONS = [
     {
         id: "quick.db-touched",
         scope: "quick",
-        title: "reconocer si la tarea llegó a tocar una base de datos",
+        title: "reconocer si la tarea mutó una base de datos; leer no declara la señal",
         authority: "agent",
         ownership: "cli-owned",
         document: DB_SCRIPTS_ONLY,
         attribution: PLAN_ATTRIBUTION,
-        // A quick that never went near a database has no statement to derive and no
+        // A read-only quick has no mutation statement to derive and no
         // `SCRIPTS.sql` to hand back, so the row below it used to demand an artifact
         // that should not exist. Declaring the signal is what lets the rule apply
         // exactly where it has something to govern.
@@ -1049,7 +1099,7 @@ export const FLOW_DECISIONS = [
         effects: ["local_additive"],
         condition: {
             threshold: { observed: "quick.db-touched", of: ["quick.db-touched"], min: 1 },
-            otherwise: "la tarea no tocó ninguna base de datos: no hay sentencia que derivar",
+            otherwise: "la tarea no mutó la base de datos: las lecturas no exigen scripts",
         },
         // Migrated with the PLAN tranche and not with QUICK, for the same reason
         // CODE-POLICIES was: `plan-exec` reads this module too, and retiring its rule
@@ -1066,7 +1116,7 @@ export const FLOW_DECISIONS = [
             execution: { kind: "internal", operation: "session.artifacts", dump: ["scripts"] },
             evidence: ["quick.scripts-derivados"],
             idempotent: true,
-            recovery: "escribí el DDL o DML en el SCRIPTS.sql de la sesión y volvé a devolver el dump; ejecutarlo no es una alternativa que este contrato admita",
+            recovery: "escribí el DDL o DML en SCRIPTS.sql o scripts/*.sql de la sesión y corré aw flow advance; si sólo leíste la base, retirá la señal con aw flow retract --session <código> --signal quick.db-touched; el CLI no ejecuta SQL",
         },
     },
     {
@@ -1462,6 +1512,7 @@ export const FLOW_DECISIONS = [
         // person would have been confirming a write that already happened. The
         // doctrine's own line is `edit_in_place_with_confirm(spec) + stamp`.
         publishes: { approve: "Aprobar y guardar" },
+        reenters: { label: "Refinar", from: "spec-refine.content-authoring" },
         alternatives: [
             {
                 label: "Aprobar y guardar",
@@ -1736,6 +1787,7 @@ export const FLOW_DECISIONS = [
         document: PLAN_NEW_LOOP,
         attribution: PLAN_ATTRIBUTION,
         publishes: { approve: "Aprobar y guardar" },
+        reenters: { label: "Refinar", from: "plan-new.phase-shaping" },
         alternatives: [
             {
                 label: "Aprobar y guardar",
@@ -1949,6 +2001,7 @@ export const FLOW_DECISIONS = [
         document: PLAN_REFINE_LOOP,
         attribution: PLAN_ATTRIBUTION,
         publishes: { approve: "Aprobar y guardar" },
+        reenters: { label: "Refinar", from: "plan-refine.journey-map" },
         alternatives: [
             {
                 label: "Aprobar y guardar",
@@ -2050,9 +2103,14 @@ export const FLOW_DECISIONS = [
         document: PLAN_EXEC_LOOP,
         attribution: PLAN_ATTRIBUTION,
         condition: {
-            threshold: { observed: "plan-exec.entry-gap-recognition", min: 1 },
-            otherwise: "el gate de entrada no encontró ningún hueco: no hay severidad que clasificar",
+            threshold: {
+                observed: "plan-exec.entry-gap-recognition",
+                of: ["plan.entry-gap-structural"],
+                min: 1,
+            },
+            otherwise: "el gate de entrada no encontró un hueco estructural: no hay que escalar",
         },
+        handoff: { kind: "handoff", destination: "plan-refine" },
     },
     {
         id: "plan-exec.normalization-consent",
@@ -2088,6 +2146,23 @@ export const FLOW_DECISIONS = [
             },
         ],
     },
+    {
+        id: "plan-exec.unchanged-phase-consent",
+        scope: "plan-exec",
+        title: "aprobar la validación sin cambios de las fases detectadas al entrar",
+        authority: "human",
+        ownership: "cli-owned",
+        document: PLAN_EXEC_LOOP,
+        attribution: PLAN_ATTRIBUTION,
+        alternatives: [
+            {
+                label: "Aprobar validación sin cambios",
+                consequence: "se validan con evidencia real sólo las fases sin tareas abiertas observadas al entrar; no se cierra ninguna tarea y el crédito se puede anular",
+                recommended: true,
+                outcome: { kind: "continue" },
+            },
+        ],
+    },
     {
         id: "plan-exec.source-scope",
         scope: "plan-exec",
@@ -2144,7 +2219,7 @@ export const FLOW_DECISIONS = [
             execution: { kind: "internal", operation: "plan-exec.batch-infer" },
             evidence: ["plan.batch-inferido"],
             idempotent: true,
-            recovery: "reanudá con 'aw flow advance': el batch inferido conserva su digest y sólo se vuelve a inferir si todavía no quedó sellado",
+            recovery: "reanudá con 'aw flow advance'; si el plan cambió, usá 'aw flow recover --session <código> --reinfer-batch' para ver el diff antes de re-sellar el lote no publicado",
         },
     },
     {
@@ -2177,7 +2252,7 @@ export const FLOW_DECISIONS = [
         ownership: "cli-owned",
         document: CODE_POLICIES_MD,
         attribution: PLAN_ATTRIBUTION,
-        effects: ["local_additive"],
+        effects: ["local_additive", "mutate_overwrite"],
         // BEFORE `plan-exec.implementation`, and the position is the whole rule: the
         // policy says a loop that edits code edits inside its unit, and a unit obtained
         // after the first write would be an isolation nobody was ever isolated by.
@@ -2364,7 +2439,7 @@ export const FLOW_DECISIONS = [
         document: PLAN_EXEC_LOOP,
         attribution: PLAN_ATTRIBUTION,
         effects: ["execute"],
-        route_control: ROUTE_VALIDATION,
+        route_control: ROUTE_PHASE_VALIDATION,
         // Running the proofs the plan itself declares is the run verifying its own
         // work: custody covers the `execute`, and the real output stays mandatory.
         custody: "run",
@@ -2384,9 +2459,11 @@ export const FLOW_DECISIONS = [
                 kind: "external",
                 reason: "correr las pruebas de fase es ejecutar código, nunca una operación interna",
             },
-            evidence: ["plan.validaciones-de-fase-verdes"],
+            // One proof per source of the batch: what ties the output to THIS batch's
+            // checkout, so an envelope recycled from another batch cannot credit it.
+            evidence: ["plan.validaciones-de-fase-verdes", SOURCE_BOUNDED_EVIDENCE],
             idempotent: true,
-            recovery: "arreglá lo que la validación reprobó y volvé a correr las pruebas afectadas: la transición sigue pendiente hasta que su salida real vuelva en verde",
+            recovery: "arreglá lo que la validación reprobó y volvé a correr las pruebas afectadas: la transición sigue pendiente hasta que su salida real vuelva en verde, con una prueba 'aw flow prove --source <alias>' de cada fuente del lote tomada después de sus cambios",
         },
     },
     {
@@ -2406,7 +2483,57 @@ export const FLOW_DECISIONS = [
         ownership: "cli-owned",
         document: CODE_POLICIES_MD,
         attribution: PLAN_ATTRIBUTION,
-        route_control: ROUTE_REVIEW,
+        answer_contract: "batch-review",
+    },
+    {
+        id: "plan-exec.batch-commit-proposal",
+        scope: "plan-exec",
+        title: "proponer el mensaje de commit por fuente sobre las rutas del lote",
+        authority: "agent",
+        ownership: "cli-owned",
+        document: PLAN_EXEC_LOOP,
+        attribution: PLAN_ATTRIBUTION,
+    },
+    {
+        id: "plan-exec.batch-commit-authorization",
+        scope: "plan-exec",
+        title: "aprobar los commits propuestos del lote con sus rutas y mensajes",
+        authority: "human",
+        ownership: "cli-owned",
+        document: PLAN_EXEC_LOOP,
+        attribution: PLAN_ATTRIBUTION,
+        authorizes: { approve: "Aprobar los commits del lote", transition: "plan-exec.batch-commit" },
+        alternatives: [
+            {
+                label: "Aprobar los commits del lote",
+                consequence: "el CLI crea sólo los commits del lote aprobado, por fuente y por rutas",
+                recommended: true,
+                outcome: { kind: "continue" },
+            },
+        ],
+    },
+    {
+        id: "plan-exec.batch-commit",
+        scope: "plan-exec",
+        title: "crear y comprobar los commits aprobados del lote",
+        authority: "cli",
+        ownership: "cli-owned",
+        document: PLAN_EXEC_LOOP,
+        attribution: PLAN_ATTRIBUTION,
+        effects: ["execute", "local_additive"],
+        custody: "run",
+        action: {
+            invocation: {
+                program: "aw",
+                args: ["flow", "advance", "--code", "{code}"],
+                target: ".",
+                input: null,
+            },
+            execution: { kind: "internal", operation: "plan-exec.batch-commit" },
+            evidence: ["plan.batch-commits-verificados"],
+            idempotent: true,
+            recovery: "reanudá con aw flow advance: se reconocen los recibos y commits propios ya aplicados antes de avanzar",
+        },
     },
     {
         id: "plan-exec.batch-close",
@@ -2432,7 +2559,7 @@ export const FLOW_DECISIONS = [
             execution: { kind: "internal", operation: "plan-exec.batch-close" },
             evidence: ["plan.batch-publicado"],
             idempotent: true,
-            recovery: "reanudá con 'aw flow advance': el batch conserva su before/after sellado y o termina exactamente esa publicación o rechaza el plan movido",
+            recovery: "reanudá con 'aw flow advance'; si el plan cambió antes de publicar, mirá el diff con 'aw flow recover --session <código> --reinfer-batch' y volvé a validar el lote",
         },
     },
     // ── The settlement, between the last batch and the final validation ──────
@@ -2522,7 +2649,6 @@ export const FLOW_DECISIONS = [
         ownership: "cli-owned",
         document: PLAN_EXEC_LOOP,
         attribution: PLAN_ATTRIBUTION,
-        route_control: ROUTE_VALIDATION,
         // BEFORE Git, and the real walk is what proved it: the registry had inherited
         // an order where the plan was committed and only then validated and stamped.
         // The document says the opposite — "last Batch also runs final validation
@@ -2559,7 +2685,7 @@ export const FLOW_DECISIONS = [
     {
         id: "plan-exec.commit-authorization",
         scope: "plan-exec",
-        title: "aprobar los commits del batch o preautorizarlos condicionalmente",
+        title: "aprobar los commits de una corrida heredada",
         authority: "human",
         ownership: "cli-owned",
         document: CODE_POLICIES_MD,
@@ -2578,12 +2704,6 @@ export const FLOW_DECISIONS = [
                 recommended: true,
                 outcome: { kind: "continue" },
             },
-            {
-                label: "Dejar el batch sin commitear",
-                consequence: "los cambios quedan en el árbol de trabajo y el batch se registra sin commitear en CHECKPOINT y BACKLOG",
-                recommended: false,
-                outcome: { kind: "continue" },
-            },
         ],
     },
     {
@@ -2663,7 +2783,7 @@ export const FLOW_DECISIONS = [
             // Integrating an already-integrated session is a no-op that reports the same
             // thing, which is what lets the recovery end where it started.
             idempotent: true,
-            recovery: "una unidad en conflicto conserva su merge y sus commits: resolvé con 'aw fix-git --path <fuente>' (prepare → apply → commit --confirm) y volvé a correr la integración; la transición sigue pendiente mientras la sesión conserve una unidad",
+            recovery: "una unidad en conflicto conserva su merge y sus commits: resolvé con 'aw fix-git --path <ruta que reportó la integración>' (prepare → apply → commit --confirm) y volvé a correr la integración; la transición sigue pendiente mientras la sesión conserve una unidad",
         },
     },
     {
@@ -3035,6 +3155,14 @@ export const FLOW_DECISIONS = [
  * a second list: one field, one reason, one guard.
  */
 export const COMMAND_EXCLUSIONS = [
+    {
+        command: "workspace-commit",
+        reason: "comando transversal sin corrida propia: prepare sella mensaje y pathspec del workspace y apply exige ese digest; el cierre del chasis también lo invoca sólo después del consentimiento humano",
+    },
+    {
+        command: "workspace-move",
+        reason: "mudanza o reparación puntual de un hub; valida el destino y las referencias vivas antes de mover, sin abrir una corrida adicional",
+    },
     {
         command: "spec-new",
         reason: "comando `/w:` de una sola pasada que no abre loop: sin corrida que dirigir, su gate de división lo aplica el propio comando con la regla de modules/SPLIT-GATE.md, que por eso conserva su enunciado",
@@ -3091,8 +3219,16 @@ export const COMMAND_EXCLUSIONS = [
     { command: "stack", reason: "detección de stack informativa" },
     { command: "sources", reason: "inventario de fuentes del workspace" },
     { command: "set-working-branch", reason: "configuración declarativa de rama" },
+    {
+        command: "doc-branch",
+        reason: "asociación declarativa de una rama de trabajo a un documento, con lectura sin efectos y escritura append-only después de asegurar la rama",
+    },
     { command: "set-qa-branch", reason: "configuración declarativa de rama" },
+    { command: "set-exception-branch", reason: "configuración declarativa de rama" },
+    { command: "set-edit-mode", reason: "configuración declarativa del workspace" },
+    { command: "set-pipeline", reason: "configuración declarativa de build y test por fuente" },
     { command: "remove-source", reason: "operación de configuración del workspace" },
+    { command: "add-source", reason: "operación de configuración del workspace" },
     { command: "git-flow", reason: "utilidad de ramas sin recorrido de flow" },
     { command: "merge-state", reason: "lectura del estado de una fusión" },
     { command: "attach-multiroot", reason: "configuración de multiroot" },
@@ -3113,6 +3249,11 @@ export const COMMAND_EXCLUSIONS = [
         reason: "comparte la clasificación de export-reports: selección semántica del agente más corpus, numeración y escritura del CLI, con su propio destino documental",
     },
     { command: "history-update", reason: "reparación del registro durable" },
+    {
+        command: "session-pause",
+        reason: "marca explícita de pausa por decisión humana, fuera de recorridos",
+    },
+    { command: "history", reason: "reconciliación de sólo lectura del registro de sesiones" },
     { command: "project-md-upsert", reason: "escritura del bloque de proyecto en el host" },
     {
         command: "workspace-migrate",
@@ -3163,25 +3304,42 @@ export function journeyOfFlow(flow) {
     const at = (placement) => transversal.filter((decision) => decision.placement === placement);
     return [...at("prefix"), ...decisionsOfScope(flow), ...at("suffix")];
 }
+const FINALIZE_TRANSITION = "chassis.finalize";
 /**
  * The actual cursor journey for a persisted run.
  *
- * PLAN-exec alone has a repeatable middle: every sealed batch appends another
- * copy of `batch-inference … batch-close` to the journey while an open phase
- * remains.  The cursor therefore remains a normal append-only prefix — it never
- * rewinds to make a second batch look like a first one — and the final close
- * simply stops adding a copy, exposing final validation, Git and `done`.
+ * The registry list, with two kinds of repetition layered on it: plan-exec's
+ * batch segment (see {@link batchSegments}) and the reentries the run recorded
+ * (see {@link JourneyReentry}). Both only ever INSERT rows at or after the
+ * cursor, so the cursor remains an append-only prefix — it never rewinds, which
+ * would make already-applied transitions re-runnable.
  *
  * This intentionally accepts only the small state shape it reads, avoiding a
  * runtime dependency back from the authority registry to the run-state domain.
  */
 export function journeyForState(state, baseJourney) {
+    return expandJourney(state, baseJourney).rows;
+}
+/** {@link journeyForState} with the reentry each row came from. */
+export function expandJourney(state, baseJourney) {
     // The runtime normally supplies no base, so this reads the registry directly.
-    // A controlled host may supply its own fixture journey: PLAN-exec still adds
-    // its cursor only when that journey actually contains the batch segment.
-    const base = baseJourney ?? journeyOfFlow(state.flow);
-    if (state.flow !== "plan-exec")
-        return base;
+    // A controlled host may supply its own fixture journey.
+    const source = baseJourney ?? journeyOfFlow(state.flow);
+    // A run finalized by an older CLI must keep its completed cursor: inserting
+    // a human gate before an already applied finalize would reinterpret its close.
+    const base = state.applied?.includes(FINALIZE_TRANSITION) && !state.applied.includes("chassis.commit-choice")
+        ? source.filter((row) => row.id !== "chassis.commit-choice")
+        : source;
+    const batched = state.flow === "plan-exec" ? batchSegments(state, base) : base;
+    return withReentries(batched, base, state.reentries ?? []);
+}
+/**
+ * PLAN-exec's repeatable middle: every sealed batch appends another copy of
+ * `batch-eligibility-signal … batch-close` while an open phase remains, and the
+ * final close simply stops adding a copy, exposing final validation, Git and
+ * `done`. A fixture journey without the segment keeps its ordinary path.
+ */
+function batchSegments(state, base) {
     const first = base.findIndex((decision) => decision.id === "plan-exec.batch-eligibility-signal");
     const last = base.findIndex((decision) => decision.id === "plan-exec.batch-close");
     // A registry build missing either boundary must keep the ordinary path rather
@@ -3208,7 +3366,9 @@ export function journeyForState(state, baseJourney) {
     const noWorkInferenceStarted = copies === 0 &&
         inference >= first &&
         (state.applied?.includes("plan-exec.batch-inference") === true ||
-            state.boundary === "plan-exec.batch-inference");
+            state.boundary === "plan-exec.batch-inference" ||
+            // A close there moves the boundary to its finalize; the row stood on is the same.
+            (state.reentries ?? []).some((reentry) => reentry.kind === "close" && reentry.transition === "plan-exec.batch-inference"));
     if (noWorkInferenceStarted) {
         return [...base.slice(0, first), ...base.slice(first, inference + 1), ...base.slice(last + 1)];
     }
@@ -3223,6 +3383,132 @@ export function journeyForState(state, baseJourney) {
         ...base.slice(last + 1),
     ];
 }
+/**
+ * Lay the recorded reentries over the journey, oldest first.
+ *
+ * Each one names its row as the run walked it at that moment, which is exactly
+ * what replaying them in order rebuilds. A reentry whose rows this build no
+ * longer has is left out rather than approximated — and so is the reopen of a
+ * close left out — so the cursor check names the mismatch instead of the run
+ * walking an invented stretch.
+ */
+function withReentries(rows, base, reentries) {
+    let journey = { rows, copies: rows.map(() => 0) };
+    let cut = null;
+    for (const [index, reentry] of reentries.entries()) {
+        const ordinal = index + 1;
+        if (reentry.kind === "refine") {
+            journey = insertRedraft(journey, base, reentry, ordinal);
+        }
+        else if (reentry.kind === "review") {
+            journey = insertReview(journey, base, reentry, ordinal);
+        }
+        else if (reentry.kind === "reinfer") {
+            journey = insertBatchRevalidation(journey, base, reentry, ordinal);
+        }
+        else if (reentry.kind === "close") {
+            const closed = closeAt(journey, base, reentry, ordinal);
+            journey = closed?.journey ?? journey;
+            cut = closed?.cut ?? "dropped";
+        }
+        else {
+            if (cut !== "dropped")
+                journey = reopen(journey, cut, reentry, ordinal);
+            cut = null;
+        }
+    }
+    return journey;
+}
+/** Index of the `occurrence`-th row of `transition`, or -1 when there is none. */
+export function occurrenceIndex(rows, transition, occurrence) {
+    let seen = 0;
+    for (const [index, row] of rows.entries()) {
+        if (row.id !== transition)
+            continue;
+        seen += 1;
+        if (seen === occurrence)
+            return index;
+    }
+    return -1;
+}
+/** Which walk of its id the row at `index` is, counting from 1. */
+export function occurrenceAt(rows, index) {
+    const id = rows[index]?.id;
+    return rows.slice(0, index + 1).filter((row) => row.id === id).length;
+}
+function insertRedraft(journey, base, reentry, ordinal) {
+    const from = base.findIndex((decision) => decision.id === reentry.from);
+    const to = base.findIndex((decision) => decision.id === reentry.transition);
+    const origin = occurrenceIndex(journey.rows, reentry.transition, reentry.occurrence);
+    if (from < 0 || to < from || origin < 0)
+        return journey;
+    const at = origin + 1;
+    const segment = base.slice(from, to + 1);
+    return {
+        rows: [...journey.rows.slice(0, at), ...segment, ...journey.rows.slice(at)],
+        copies: [
+            ...journey.copies.slice(0, at),
+            ...segment.map(() => ordinal),
+            ...journey.copies.slice(at),
+        ],
+    };
+}
+/** Restore required evidence immediately before a legacy pending close, even after reopening. */
+function insertReview(journey, base, reentry, ordinal) {
+    const row = base.find((decision) => decision.id === "plan-exec.review-findings");
+    const at = occurrenceIndex(journey.rows, reentry.transition, reentry.occurrence);
+    if (row === undefined || at < 0)
+        return journey;
+    return {
+        rows: [...journey.rows.slice(0, at), row, ...journey.rows.slice(at)],
+        copies: [...journey.copies.slice(0, at), ordinal, ...journey.copies.slice(at)],
+    };
+}
+/** Re-run validation and review before the uncommitted batch is published. */
+function insertBatchRevalidation(journey, base, reentry, ordinal) {
+    const start = base.findIndex((decision) => decision.id === "plan-exec.validation-execution");
+    const end = base.findIndex((decision) => decision.id === reentry.transition);
+    const at = occurrenceIndex(journey.rows, reentry.transition, reentry.occurrence);
+    if (start < 0 || end <= start || at < 0)
+        return journey;
+    const segment = base.slice(start, end);
+    return {
+        rows: [...journey.rows.slice(0, at), ...segment, ...journey.rows.slice(at)],
+        copies: [
+            ...journey.copies.slice(0, at),
+            ...segment.map(() => ordinal),
+            ...journey.copies.slice(at),
+        ],
+    };
+}
+function closeAt(journey, base, reentry, ordinal) {
+    const finalize = base.find((decision) => decision.id === FINALIZE_TRANSITION);
+    const at = occurrenceIndex(journey.rows, reentry.transition, reentry.occurrence);
+    if (finalize === undefined || at < 0)
+        return null;
+    return {
+        journey: {
+            rows: [...journey.rows.slice(0, at), finalize],
+            copies: [...journey.copies.slice(0, at), ordinal],
+        },
+        cut: { rows: journey.rows.slice(at), copies: journey.copies.slice(at) },
+    };
+}
+function reopen(journey, cut, reentry, ordinal) {
+    // After a close, the rows it cut are the same rows, not copies: the boundary it
+    // stood on keeps its attempts, so closing and reopening never refills a budget.
+    if (cut !== null) {
+        return { rows: [...journey.rows, ...cut.rows], copies: [...journey.copies, ...cut.copies] };
+    }
+    const from = occurrenceIndex(journey.rows, reentry.transition, reentry.occurrence);
+    if (from < 0)
+        return journey;
+    const again = journey.rows.slice(from);
+    return {
+        rows: [...journey.rows, ...again],
+        copies: [...journey.copies, ...again.map(() => ordinal)],
+    };
+}
 /**
  * The `docs/` folders a flow may write, as the chassis' boundary states them.
  *