@tacuchi/agent-workflow-cli 25.7.0 → 25.9.0

package/dist/domain/flow/run-state.js

@@ -26,7 +26,8 @@ import { canonicalJson, semanticDigest } from "../../application/semantic-operat
 import { isEffectClass, touchesTheWorld } from "../capability/effects.js";
 import { AttemptLedger } from "../capability/protocol.js";
 import { normalizeObligations, validateDecisionNote } from "../decision-note.js";
-import { journeyOfFlow } from "./authority.js";
+import { expandJourney, journeyOfFlow, } from "./authority.js";
+import { isBatchReview } from "./batch-review.js";
 import { V11_JOURNEY_BASE } from "./journey-baseline.js";
 import { assuranceForRoute, isAssuranceStatus, isRouteDisposition, } from "./route.js";
 /**
@@ -40,7 +41,7 @@ import { assuranceForRoute, isAssuranceStatus, isRouteDisposition, } from "./rou
  * turning the cap off in silence while somebody alternates CLI versions over one
  * run. Failing with a cause is the requirement; failing silently is the defect.
  */
-export const FLOW_RUN_STATE_VERSION = 12;
+export const FLOW_RUN_STATE_VERSION = 15;
 /**
  * The versions this CLI CONTINUES without adoption, newest first.
  *
@@ -50,8 +51,23 @@ export const FLOW_RUN_STATE_VERSION = 12;
  * cursor, the answers or the attempts. Every later version joins this set with its own
  * upgrade step, which is what keeps "v11 or later survives an update" true
  * without an exception per release.
+ *
+ * v13 added `reentries` and the `reentry_iteration` of attempts, observations and
+ * events. All three are absent on a run that never re-entered, which is every
+ * v12 run, so its upgrade step only re-stamps the version.
+ * It also added each batch's `base` and `credit`, a reseated run's `inherited_bases`
+ * and the `route-refused` trace kind. A v12 run has none of them either, and a
+ * batch without `base` is read as the one that was in flight when the CLI updated.
  */
-export const FLOW_RUN_STATE_CONTINUABLE = [FLOW_RUN_STATE_VERSION, 11];
+// v14 adds batch reviews, signal retractions and QUICK checkout observations.
+// Older observations and events remain unchanged.
+export const FLOW_RUN_STATE_CONTINUABLE = [
+    FLOW_RUN_STATE_VERSION,
+    14,
+    13,
+    12,
+    11,
+];
 /**
  * The versions this CLI READS, newest first.
  *
@@ -75,6 +91,14 @@ export const FLOW_RUN_STATE_READABLE = [
  */
 const CONTINUABLE_UPGRADES = {
     11: (state) => ({ ...state, version: 12, journey_base: [...V11_JOURNEY_BASE[state.flow]] }),
+    12: (state) => ({ ...state, version: 13 }),
+    // Historical reviews are never fabricated. A still-open batch must supply one.
+    13: (state) => ({ ...state, version: 14 }),
+    14: (state) => ({
+        ...state,
+        version: 15,
+        ...(state.scope ? { scope: { isolation: "unit", ...state.scope } } : {}),
+    }),
 };
 /** The CLI-owned run state inside the session folder. Machine-local, dotted. */
 export const FLOW_RUN_STATE_FILE = ".flow-run.json";
@@ -111,12 +135,47 @@ export function attemptsAt(state, transition) {
 }
 /** The monotone-counter key for one boundary, scoped when that boundary repeats in a batch. */
 export function attemptCounterKey(state, transition) {
-    const iteration = currentBatchIteration(state, transition);
-    return attemptCounterKeyForIteration(transition, iteration ?? undefined);
+    return attemptCounterKeyForIteration(transition, iterationOf(state, transition));
 }
-/** Stable counter key for a historical attempt whose batch iteration is recorded on the row. */
+/** Stable counter key for a historical attempt whose iteration is recorded on the row. */
 export function attemptCounterKeyForIteration(transition, iteration) {
-    return iteration === undefined ? transition : `${transition}@batch-${iteration}`;
+    const batch = iteration.batch_iteration === undefined ? "" : `@batch-${iteration.batch_iteration}`;
+    const reentry = iteration.reentry_iteration === undefined ? "" : `@reentry-${iteration.reentry_iteration}`;
+    return `${transition}${batch}${reentry}`;
+}
+/**
+ * The iteration of `transition` where the run stands: its batch copy and its
+ * reentry copy. Spread it into any record keyed per boundary.
+ */
+export function iterationOf(state, transition) {
+    const batch = currentBatchIteration(state, transition);
+    const reentry = currentReentryIteration(state, transition);
+    return {
+        ...(batch === null ? {} : { batch_iteration: batch }),
+        ...(reentry === null ? {} : { reentry_iteration: reentry }),
+    };
+}
+/** Whether a persisted record belongs to this iteration of its boundary. */
+export function sameIteration(record, iteration) {
+    return (record.batch_iteration === iteration.batch_iteration &&
+        record.reentry_iteration === iteration.reentry_iteration);
+}
+/**
+ * Which reentry inserted the row of `transition` the cursor is on, or `null` on
+ * the row's own place. Read at the cursor and backwards from it, so it answers
+ * the same before the row is applied and right after.
+ */
+export function currentReentryIteration(state, transition) {
+    if ((state.reentries ?? []).length === 0)
+        return null;
+    const { rows, copies } = expandJourney(state);
+    for (let index = Math.min(state.applied.length, rows.length - 1); index >= 0; index -= 1) {
+        if (rows[index]?.id !== transition)
+            continue;
+        const copy = copies[index] ?? 0;
+        return copy === 0 ? null : copy;
+    }
+    return null;
 }
 /**
  * The three numbers and the difference between them, computed once.
@@ -127,15 +186,28 @@ export function attemptCounterKeyForIteration(transition, iteration) {
  * directive and the recovery guard would end up disagreeing about the same run.
  */
 function spendAt(state, transition) {
-    const iteration = currentBatchIteration(state, transition);
-    const rows = state.attempts.filter((attempt) => attempt.transition === transition &&
-        (iteration === null
-            ? attempt.batch_iteration === undefined
-            : attempt.batch_iteration === iteration));
+    const iteration = iterationOf(state, transition);
+    const recorded = state.attempts.filter((attempt) => attempt.transition === transition && sameIteration(attempt, iteration));
+    const seen = new Set();
+    const rows = recorded.filter((attempt) => {
+        const key = `${attempt.invocation_id}:${attempt.attempt}:${attempt.request_digest}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
     const key = attemptCounterKey(state, transition);
-    const floor = state.attempt_floor?.[key] ?? 0;
+    // Old runs may hold a twin row and a counter raised over that twin. Removing
+    // both copies of the same resend from the reading preserves the anti-rollback
+    // excess, which is the portion the monotone floor still has to protect.
+    const floor = Math.max(0, (state.attempt_floor?.[key] ?? 0) - (recorded.length - rows.length));
     const granted = state.attempt_grants?.[key] ?? 0;
-    return { rows, floor, granted, spent: Math.max(0, Math.max(rows.length, floor) - granted) };
+    return {
+        rows,
+        floor,
+        granted,
+        spent: Math.max(0, Math.max(rows.filter((row) => row.approval !== true).length, floor) - granted),
+    };
 }
 /**
  * The whole accounting of one transition, conflicts named and answerability read.
@@ -150,23 +222,24 @@ export function attemptAccountingAt(state, transition) {
     // — and a projection that disagrees with the state it describes is the very
     // thing this reading exists to stop. It cannot mask a real divergence: a
     // counter that runs AHEAD of the rows stays ahead of this maximum.
-    const floor = Math.max(read, rows.length);
+    const paid = rows.filter((row) => row.approval !== true).length;
+    const floor = Math.max(read, paid);
     const ordinals = rows.map((attempt) => attempt.attempt);
     const conflicts = [];
-    if (floor > rows.length) {
+    if (floor > paid) {
         conflicts.push({
             between: [
                 { name: "attempt_floor", value: floor },
-                { name: "attempts", value: rows.length },
+                { name: "attempts", value: paid },
             ],
             cause: "el contador monótono declara más intentos que las filas persistidas: o se restauró una copia anterior del ledger, o una escritura murió entre el contador y el estado",
         });
     }
-    if (granted > Math.max(rows.length, floor)) {
+    if (granted > Math.max(paid, floor)) {
         conflicts.push({
             between: [
                 { name: "attempt_grants", value: granted },
-                { name: "attempts", value: Math.max(rows.length, floor) },
+                { name: "attempts", value: Math.max(paid, floor) },
             ],
             cause: "se perdonan más intentos de los que esta transición llegó a registrar",
         });
@@ -228,7 +301,8 @@ export function reconcileAttemptsAt(state, transition) {
         };
     }
     const { rows, floor: read, granted, spent } = spendAt(state, transition);
-    const floor = Math.max(read, rows.length);
+    const paid = rows.filter((row) => row.approval !== true).length;
+    const floor = Math.max(read, paid);
     const accounting = attemptAccountingAt(state, transition);
     const repairs = [];
     // What is repaired is the EFFECTIVE spend, not the raw difference between the
@@ -237,7 +311,7 @@ export function reconcileAttemptsAt(state, transition) {
     // against that difference would forgive it again on every single advance and
     // quietly remove the cap. Written against the spend, the second reading finds
     // `spent === rows` and has nothing to do.
-    const unforgiven = spent - rows.length;
+    const unforgiven = spent - paid;
     if (unforgiven > 0) {
         repairs.push({
             rule: "forgive-counter-excess",
@@ -247,7 +321,7 @@ export function reconcileAttemptsAt(state, transition) {
             after: granted + unforgiven,
         });
     }
-    const recorded = Math.max(rows.length, floor);
+    const recorded = Math.max(paid, floor);
     if (granted > recorded) {
         repairs.push({
             rule: "clamp-grants",
@@ -287,10 +361,11 @@ function conflictCause(accounting, field) {
 function repeatedOrdinal(state) {
     const seen = new Map();
     for (const row of state.attempts) {
-        const ordinals = seen.get(row.invocation_id) ?? new Set();
-        if (ordinals.has(row.attempt))
+        const ordinals = seen.get(row.invocation_id) ?? new Map();
+        const previous = ordinals.get(row.attempt);
+        if (previous !== undefined && previous !== row.request_digest)
             return row.attempt;
-        ordinals.add(row.attempt);
+        ordinals.set(row.attempt, row.request_digest);
         seen.set(row.invocation_id, ordinals);
     }
     return null;
@@ -316,11 +391,10 @@ export function applyAttemptReconciliation(state, reconciliation) {
         grants[key] = repair.after;
         next = sealRunState({ ...withoutSeal(next), attempt_grants: grants });
     }
-    const iteration = currentBatchIteration(next, reconciliation.transition);
     return withEvent(next, {
         kind: "reconciled",
         transition: reconciliation.transition,
-        ...(iteration === null ? {} : { batch_iteration: iteration }),
+        ...iterationOf(next, reconciliation.transition),
         operation: "flow.attempt-reconciliation",
         repairs: reconciliation.repairs,
     });
@@ -349,12 +423,8 @@ function unanswerableAt(state) {
     }
     return null;
 }
-export function recoveryBlockedAt(state, transition) {
-    const iteration = currentBatchIteration(state, transition);
-    const trace = state.events.filter((event) => event.transition === transition &&
-        (iteration === null
-            ? event.batch_iteration === undefined
-            : event.batch_iteration === iteration));
+export function recoveryBlockedAt(state, transition, iteration = iterationOf(state, transition)) {
+    const trace = state.events.filter((event) => event.transition === transition && sameIteration(event, iteration));
     const material = [...trace].reverse().find(declaresMaterialEffect);
     if (material !== undefined)
         return { reason: "materialized", event: material };
@@ -377,7 +447,9 @@ function declaresMaterialEffect(event) {
     // more block a recovery than reading the file could.
     if (event.kind === "reconciled" ||
         event.kind === "aligned" ||
+        event.kind === "route-refused" ||
         event.kind === "restarted" ||
+        event.kind === "retracted" ||
         event.kind === "annulled") {
         return false;
     }
@@ -417,6 +489,7 @@ export const PLAN_EXEC_BATCH_STAGES = [
     "deviation",
     "validating",
     "reviewing",
+    "batch-committing",
     "closed",
     "committing",
     "integrating",
@@ -634,6 +707,101 @@ export function upgradeContinuable(state) {
     }
     return sealRunState(withoutSeal(current));
 }
+/** Record a reentry of the journey, after every one already recorded. */
+export function withReentry(state, reentry) {
+    return sealRunState({
+        ...withoutSeal(state),
+        reentries: [...(state.reentries ?? []), reentry],
+    });
+}
+/**
+ * Take back the last reentry, for the close that recorded its intention and then
+ * could not happen. The field goes back to absent when it empties, so the run
+ * serializes the bytes it had before the intention.
+ */
+export function withoutLastReentry(state) {
+    const { reentries: _all, ...rest } = withoutSeal(state);
+    const kept = (state.reentries ?? []).slice(0, -1);
+    return sealRunState(kept.length === 0 ? rest : { ...rest, reentries: kept });
+}
+/** Seal the base of one batch; a batch that already has one keeps it. */
+export function withPlanExecBatchBase(state, batchId, base) {
+    const batches = state.batches ?? [];
+    const target = batches.find((batch) => batch.id === batchId);
+    // A re-run of the acquisition on the same batch must not move its base: the
+    // batch would then be compared against its own half-done work.
+    if (target === undefined || target.base !== undefined)
+        return state;
+    return sealRunState({
+        ...withoutSeal(state),
+        batches: batches.map((batch) => (batch.id === batchId ? { ...batch, base } : batch)),
+    });
+}
+/** Record the proofs that credited one batch. */
+export function withPlanExecBatchCredit(state, batchId, credit) {
+    const batches = state.batches ?? [];
+    if (!batches.some((batch) => batch.id === batchId))
+        return state;
+    return sealRunState({
+        ...withoutSeal(state),
+        batches: batches.map((batch) => batch.id === batchId ? { ...batch, credit, credit_phases: [...batch.phases] } : batch),
+    });
+}
+export function withPlanExecBatchUpdate(state, id, update) {
+    return sealRunState({
+        ...withoutSeal(state),
+        batches: (state.batches ?? []).map((batch) => (batch.id === id ? update(batch) : batch)),
+    });
+}
+/** Re-seal the SAME unpublished batch; old validation/review cannot credit a new base. */
+export function withReinferredPlanExecBatch(state, batchId, planDigest, anchor) {
+    const replaced = withPlanExecBatchUpdate(state, batchId, (batch) => {
+        const { credit: _credit, credit_phases: _phases, review: _review, commit_proposal: _proposal, ...rest } = batch;
+        return { ...rest, plan_digest: planDigest, stage: "inferred" };
+    });
+    const traced = withPlanExecBatchStage(replaced, batchId, "inferred", "plan-exec.batch-inference", "entered");
+    if (anchor === null)
+        return traced;
+    const reentered = withReentry(traced, {
+        kind: "reinfer",
+        transition: anchor,
+        occurrence: state.applied.filter((id) => id === anchor).length + 1,
+        from: "plan-exec.validation-execution",
+    });
+    return withPendingAction(withBoundary(reentered, "plan-exec.validation-execution"), null);
+}
+/** Old runs that closed even one batch without a commit result stay on the old tail. */
+export function legacyPlanExecCommits(state) {
+    if (state.skipped.includes("plan-exec.batch-commit-proposal"))
+        return true;
+    const acquired = state.applied.filter((transition) => transition === "plan-exec.unit-acquisition").length;
+    return (state.batches ?? []).some((batch) => (batch.published_plan_digest !== undefined && batch.commit_result === undefined) ||
+        (batch.iteration === state.batch_loop?.iteration &&
+            batch.snapshot === undefined &&
+            acquired >= batch.iteration));
+}
+/** Record only the current iteration's review, never borrowing one from a prior batch. */
+export function withPlanExecBatchReview(state, review) {
+    return sealRunState({
+        ...withoutSeal(state),
+        batches: (state.batches ?? []).map((batch) => batch.iteration === state.batch_loop?.iteration ? { ...batch, review } : batch),
+    });
+}
+/** A legacy close may have passed the old untyped review. Insert a fresh, answerable copy. */
+export function withPendingBatchReview(state) {
+    const review = "plan-exec.review-findings";
+    if (state.flow !== "plan-exec" || state.boundary !== "plan-exec.batch-close")
+        return state;
+    const batch = (state.batches ?? []).find((entry) => entry.published_plan_digest === undefined);
+    if (batch === undefined || batch.review !== undefined)
+        return state;
+    return withBoundary(withReentry(state, {
+        kind: "review",
+        transition: "plan-exec.batch-close",
+        from: review,
+        occurrence: state.applied.filter((id) => id === "plan-exec.batch-close").length + 1,
+    }), review);
+}
 /** Record one inferred or declared batch, refusing duplicate ids at the caller's boundary. */
 export function withPlanExecBatch(state, batch) {
     const batches = state.batches ?? [];
@@ -697,6 +865,7 @@ const PLAN_EXEC_BATCH_STAGE_BY_TRANSITION = {
     "plan-exec.deviation-recognition": "deviation",
     "plan-exec.validation-execution": "validating",
     "plan-exec.review-findings": "reviewing",
+    "plan-exec.batch-commit": "batch-committing",
     // These only occur after the final batch publication. They therefore extend
     // the last closed batch's trace instead of fabricating a new one for Git/done.
     "plan-exec.final-validation": "validating",
@@ -772,6 +941,9 @@ export const PLAN_EXEC_BATCH_LOOP_TRANSITIONS = new Set([
     "plan-exec.validation-execution",
     "plan-exec.deferred-check",
     "plan-exec.review-findings",
+    "plan-exec.batch-commit-proposal",
+    "plan-exec.batch-commit-authorization",
+    "plan-exec.batch-commit",
     "plan-exec.batch-close",
 ]);
 /** Seal the plan bytes the batch publication actually produced. */
@@ -817,6 +989,33 @@ export function withPlanExecBatchPublicationPrepared(state, batchId, publication
 export function withHandoff(state, handoff) {
     return sealRunState({ ...withoutSeal(state), handoff });
 }
+export function withPlanExecEntry(state, entry) {
+    return sealRunState({ ...withoutSeal(state), plan_exec_entry: entry });
+}
+export function withDecisionDate(state, date) {
+    return state.decision_date === date
+        ? state
+        : sealRunState({ ...withoutSeal(state), decision_date: date });
+}
+/** Both the human exit and the structural rule deliver the same recoverable destination. */
+export function planRefineHandoff(state, decisions, selection) {
+    const plan = state.scope?.plan ?? state.plan_exec_entry?.plan ?? null;
+    const packageBody = {
+        plan,
+        observations: state.observations.filter((observation) => observation.transition.startsWith("plan-exec.entry-") ||
+            observation.transition.startsWith("plan-exec.deviation-")),
+        decisions: plan === null
+            ? { ...decisions, recovery: "nombrá el plan que debe refinar /w:plan-refine <plan>" }
+            : decisions,
+        selection,
+    };
+    return {
+        destination: "plan-refine",
+        command: plan === null ? "/w:plan-refine <plan>" : `/w:plan-refine ${plan}`,
+        package: packageBody,
+        package_digest: semanticDigest(packageBody),
+    };
+}
 /** Persist the gate's executable consequence before the run leaves that boundary. */
 export function withSelectedChoice(state, selected) {
     return sealRunState({ ...withoutSeal(state), selected_choice: selected });
@@ -837,6 +1036,72 @@ export function withDecisionPreparation(state, preparation) {
 export function withFixPreview(state, preview) {
     return sealRunState({ ...withoutSeal(state), fix_preview: preview });
 }
+export function withQuickCheckouts(state, checkouts) {
+    if (checkouts === null && state.quick_checkouts === undefined)
+        return state;
+    return state.flow === "quick"
+        ? sealRunState({ ...withoutSeal(state), quick_checkouts: checkouts })
+        : state;
+}
+/** Remove a mistaken signal only before any of its consumers has used it. */
+export function retractSignal(state, journey, signal) {
+    const producers = journey.filter((row) => row.signals?.includes(signal)).map((row) => row.id);
+    const consumers = journey.filter((row) => {
+        const rule = row.condition?.threshold;
+        return (rule !== undefined &&
+            producers.includes(rule.observed) &&
+            (rule.of === undefined || rule.of.includes(signal)));
+    });
+    if (producers.length === 0 || consumers.length === 0) {
+        return {
+            ok: false,
+            failure: {
+                code: "FLOW_RETRACT_SIGNAL_UNKNOWN",
+                message: `la señal '${signal}' no tiene un consumidor retirable en este recorrido`,
+                action: "usá una señal declarada por el recorrido y consumida por una condición pendiente",
+            },
+        };
+    }
+    const removed = state.observations.filter((item) => item.signals.includes(signal) && sameIteration(item, iterationOf(state, item.transition)));
+    if (removed.length === 0)
+        return { ok: true, state };
+    const consumed = consumers.find((row) => removed.some((observation) => signalWasConsumed(state, row, observation)));
+    if (consumed !== undefined) {
+        return {
+            ok: false,
+            failure: {
+                code: "FLOW_RETRACT_ALREADY_CONSUMED",
+                message: `'${consumed.id}' ya aplicó o dejó una ejecución sin resolver; no se retira '${signal}'`,
+                action: "conservá la señal: retirar no revierte decisiones ni efectos ya ejercidos",
+            },
+        };
+    }
+    const updated = sealRunState({
+        ...withoutSeal(state),
+        observations: state.observations.map((item) => removed.includes(item)
+            ? { ...item, signals: item.signals.filter((value) => value !== signal) }
+            : item),
+    });
+    return {
+        ok: true,
+        state: withEvent(updated, {
+            kind: "retracted",
+            transition: state.boundary ?? producers[0] ?? "",
+            ...iterationOf(state, state.boundary ?? producers[0] ?? ""),
+            operation: "flow.retract",
+            signal,
+            observations: removed,
+        }),
+    };
+}
+function signalWasConsumed(state, consumer, observation) {
+    if (consumer.condition?.threshold.observed !== observation.transition)
+        return false;
+    // Only a consumer after THIS producer occurrence can have consumed its signal.
+    const producer = state.applied.lastIndexOf(observation.transition);
+    const consumed = state.applied.slice(producer + 1).includes(consumer.id);
+    return consumed || recoveryBlockedAt(state, consumer.id, observation) !== null;
+}
 /**
  * Record what the closure owes — written once, when the batch loop ends.
  *
@@ -954,7 +1219,7 @@ export function restatesLastEvent(state, event) {
     if (last === undefined || last.kind !== "failed" || event.kind !== "failed")
         return false;
     return (last.transition === event.transition &&
-        last.batch_iteration === event.batch_iteration &&
+        sameIteration(last, event) &&
         last.code === event.code &&
         last.message === event.message);
 }
@@ -975,7 +1240,7 @@ export function restatesLastEvent(state, event) {
  */
 export function withObservation(state, observation) {
     const repeated = state.observations.some((past) => past.transition === observation.transition &&
-        past.batch_iteration === observation.batch_iteration &&
+        sameIteration(past, observation) &&
         sameSignals(past.signals, observation.signals));
     if (repeated)
         return state;
@@ -1310,6 +1575,9 @@ function checkRecordShape(parsed, invalid) {
     if (version >= 12 && !isStringArray(parsed.journey_base)) {
         return invalid("no dice contra qué recorrido se escribió su cursor");
     }
+    if (!isReentryArray(parsed.reentries)) {
+        return invalid("declara una reentrada sin tipo, frontera, ocurrencia u origen");
+    }
     if (parsed.exhausted_reruns !== undefined && !isStringArray(parsed.exhausted_reruns)) {
         return invalid("declara vueltas de fronteras agotadas que no son transiciones");
     }
@@ -1350,8 +1618,91 @@ function checkCommonRecordShape(parsed, invalid) {
     if (!isCounterMap(parsed.attempt_floor) || !isCounterMap(parsed.attempt_grants)) {
         return invalid("trae una contabilidad de intentos que no es un contador por transición");
     }
+    if (!isInheritedBaseArray(parsed.inherited_bases)) {
+        return invalid("hereda una base de batch sin sus fases o sin sus fuentes");
+    }
+    if (!isPlanExecEntry(parsed.plan_exec_entry)) {
+        return invalid("declara una entrada de plan-exec sin plan o con fases inválidas");
+    }
+    if (parsed.decision_date !== undefined &&
+        (typeof parsed.decision_date !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(parsed.decision_date))) {
+        return invalid("declara una fecha de decisión inválida");
+    }
     return null;
 }
+function isPlanExecEntry(value) {
+    if (value === undefined)
+        return true;
+    if (!isRecord(value) || !(value.plan === null || isNonEmptyString(value.plan)))
+        return false;
+    if (value.sources !== undefined &&
+        (value.plan === null || !Array.isArray(value.sources) || !value.sources.every(isNonEmptyString)))
+        return false;
+    if (value.grammar_failure !== undefined &&
+        (!isRecord(value.grammar_failure) ||
+            !isNonEmptyString(value.grammar_failure.code) ||
+            !isNonEmptyString(value.grammar_failure.message) ||
+            !isNonEmptyString(value.grammar_failure.action)))
+        return false;
+    const phases = value.phases_without_open_tasks;
+    const approval = value.approved_without_changes;
+    if (approval !== undefined &&
+        (value.plan === null ||
+            !Array.isArray(phases) ||
+            !Array.isArray(approval) ||
+            approval.length === 0 ||
+            new Set(approval).size !== approval.length ||
+            !approval.every((phase) => phases.includes(phase))))
+        return false;
+    return (phases === null ||
+        (Array.isArray(phases) &&
+            phases.every((phase) => Number.isInteger(phase) && phase > 0) &&
+            new Set(phases).size === phases.length));
+}
+function isInheritedBaseArray(value) {
+    if (value === undefined)
+        return true;
+    return (Array.isArray(value) &&
+        value.every((entry) => isRecord(entry) &&
+            Array.isArray(entry.phases) &&
+            entry.phases.length > 0 &&
+            entry.phases.every((phase) => Number.isInteger(phase) && phase > 0) &&
+            isSourceMap(entry.base, true) &&
+            entry.base !== undefined));
+}
+/**
+ * The bases a reseated run inherits from the archived registry, read tolerantly:
+ * the archive may be the very state that could not be continued, so anything
+ * that is not a well-formed batch base is left behind rather than trusted.
+ */
+export function inheritedBasesFrom(archived) {
+    if (archived === null)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(archived);
+    }
+    catch {
+        return [];
+    }
+    if (!isRecord(parsed) || !Array.isArray(parsed.batches))
+        return [];
+    const inherited = parsed.batches.flatMap((batch) => {
+        if (!isRecord(batch) || batch.base === undefined)
+            return [];
+        const candidate = { phases: batch.phases, base: batch.base };
+        return isInheritedBaseArray([candidate]) ? [candidate] : [];
+    });
+    const earlier = isInheritedBaseArray(parsed.inherited_bases)
+        ? (parsed.inherited_bases ?? [])
+        : [];
+    return [...earlier, ...inherited];
+}
+export function withInheritedBases(state, inherited) {
+    if (inherited.length === 0)
+        return state;
+    return sealRunState({ ...withoutSeal(state), inherited_bases: [...inherited] });
+}
 /** Fields added by v10 that have no truthful default on a persisted run. */
 function checkV10RecordShape(parsed, invalid) {
     if (!isPlanExecBatchArray(parsed.batches)) {
@@ -1372,7 +1723,7 @@ function checkV10RecordShape(parsed, invalid) {
     if (!isDecisionPreparation(parsed.decision_preparation)) {
         return invalid("declara una vista de decisión sin nota, preview o linaje sellados");
     }
-    if (!isFixPreview(parsed.fix_preview)) {
+    if (!isFixPreview(parsed.fix_preview) || !isQuickCheckouts(parsed.quick_checkouts)) {
         return invalid("declara un preview de arreglo sin archivos, intención o forma del diff");
     }
     if (!isSettlement(parsed.settlement)) {
@@ -1440,7 +1791,7 @@ function isRouteProposal(value) {
             !isRouteDisposition(control.recommendation) ||
             !isRecord(control.alternatives) ||
             !isNonEmptyString(control.alternatives.apply) ||
-            !isNonEmptyString(control.alternatives.omit) ||
+            (control.alternatives.omit !== undefined && !isNonEmptyString(control.alternatives.omit)) ||
             !isNonEmptyString(control.alternatives.substitute) ||
             !isNonEmptyString(control.consequence) ||
             !isNonEmptyString(control.risk) ||
@@ -1509,6 +1860,17 @@ function isScope(value) {
         return false;
     if (!isStringArray(value.sources) || value.sources.length === 0)
         return false;
+    if (value.isolation !== undefined && value.isolation !== "unit" && value.isolation !== "in-place")
+        return false;
+    if (value.final_validation !== undefined &&
+        (!Array.isArray(value.final_validation) ||
+            !value.final_validation.every((entry) => isRecord(entry) &&
+                typeof entry.alias === "string" &&
+                [entry.build, entry.test].every((item) => isRecord(item) &&
+                    (item.command === null || typeof item.command === "string") &&
+                    (item.origin === null || item.origin === "plan" || item.origin === "source") &&
+                    (item.action === undefined || typeof item.action === "string")))))
+        return false;
     return value.sources.every((alias) => alias.trim().length > 0);
 }
 function isPlanExecBatchArray(value) {
@@ -1531,7 +1893,11 @@ function isPlanExecBatchArray(value) {
             entry.phases.length === 0 ||
             !entry.phases.every((phase) => typeof phase === "number" && Number.isInteger(phase) && phase > 0) ||
             !isStringArray(entry.tasks) ||
-            entry.tasks.length === 0 ||
+            (entry.validation_only !== undefined && typeof entry.validation_only !== "boolean") ||
+            (entry.validation_only === true && entry.tasks.length !== 0) ||
+            (entry.validation_only === false && entry.kind === "validation-only") ||
+            (entry.kind === "validation-only" ? entry.tasks.length !== 0 : entry.tasks.length === 0) ||
+            (entry.kind !== undefined && entry.kind !== "validation-only") ||
             new Set(entry.tasks).size !== entry.tasks.length ||
             typeof entry.plan_digest !== "string" ||
             entry.plan_digest.length === 0 ||
@@ -1542,7 +1908,16 @@ function isPlanExecBatchArray(value) {
             (entry.publication !== undefined &&
                 entry.publication.status === "applied" &&
                 entry.published_plan_digest !== entry.publication.after_plan_digest) ||
-            !PLAN_EXEC_BATCH_STAGES.includes(entry.stage)) {
+            !PLAN_EXEC_BATCH_STAGES.includes(entry.stage) ||
+            !isSourceMap(entry.base, true) ||
+            !isSourceMap(entry.credit, false) ||
+            !isBatchPartition(entry.partition, entry.phases, entry.mode) ||
+            !isBatchSnapshot(entry.snapshot) ||
+            !isBatchCommitProposal(entry.commit_proposal) ||
+            !isBatchCommitResult(entry.commit_result) ||
+            (entry.credit_phases !== undefined &&
+                (entry.credit === undefined || !samePhaseRange(entry.credit_phases, entry.phases))) ||
+            (entry.review !== undefined && !isBatchReview(entry.review))) {
             return false;
         }
         ids.add(entry.id);
@@ -1550,6 +1925,75 @@ function isPlanExecBatchArray(value) {
         return true;
     });
 }
+function isBatchSnapshot(value) {
+    if (value === undefined)
+        return true;
+    return (isRecord(value) &&
+        Object.values(value).every((entry) => isRecord(entry) &&
+            isNonEmptyString(entry.head) &&
+            isNonEmptyString(entry.branch) &&
+            Array.isArray(entry.dirty) &&
+            entry.dirty.every((path) => isRecord(path) && isNonEmptyString(path.path) && isNonEmptyString(path.digest))));
+}
+function isBatchCommitProposal(value) {
+    if (value === undefined)
+        return true;
+    return (isRecord(value) &&
+        isNonEmptyString(value.digest) &&
+        (value.approved_digest === undefined || isNonEmptyString(value.approved_digest)) &&
+        Array.isArray(value.sources) &&
+        value.sources.every((item) => isRecord(item) &&
+            isNonEmptyString(item.alias) &&
+            isNonEmptyString(item.message) &&
+            isStringArray(item.paths) &&
+            (item.foreign_paths === undefined || isStringArray(item.foreign_paths)) &&
+            item.paths.length > 0 &&
+            Array.isArray(item.dirty) &&
+            item.dirty.length === item.paths.length &&
+            item.dirty.every((path) => isRecord(path) && isNonEmptyString(path.path) && isNonEmptyString(path.digest))));
+}
+function isBatchCommitResult(value) {
+    if (value === undefined)
+        return true;
+    return (isRecord(value) &&
+        Object.values(value).every((receipt) => isRecord(receipt) &&
+            isNonEmptyString(receipt.after) &&
+            (receipt.before === null || isNonEmptyString(receipt.before)) &&
+            (receipt.branch === null || isNonEmptyString(receipt.branch)) &&
+            isStringArray(receipt.parents)));
+}
+function samePhaseRange(value, phases) {
+    return (Array.isArray(value) &&
+        value.length === phases.length &&
+        value.every((phase, index) => phase === phases[index]));
+}
+function isBatchPartition(value, phases, mode) {
+    if (value === undefined)
+        return true;
+    if (!isRecord(value) ||
+        !isNonEmptyString(value.reason) ||
+        !isRecord(value.effective) ||
+        value.effective.mode !== mode ||
+        !samePhaseRange(value.effective.phases, phases))
+        return false;
+    return (value.declared === null ||
+        (Array.isArray(value.declared) &&
+            value.declared.length > 0 &&
+            value.declared.every((row) => isRecord(row) &&
+                isNonEmptyString(row.id) &&
+                (row.mode === "continuous" || row.mode === "isolated") &&
+                Array.isArray(row.phases) &&
+                row.phases.length > 0 &&
+                row.phases.every((phase) => Number.isSafeInteger(phase) && phase > 0))));
+}
+/** Absent, or a non-empty alias → digest map; `nullable` admits an unobserved source. */
+function isSourceMap(value, nullable) {
+    if (value === undefined)
+        return true;
+    if (!isRecord(value) || Object.keys(value).length === 0)
+        return false;
+    return Object.values(value).every((digest) => (nullable && digest === null) || (typeof digest === "string" && digest.length > 0));
+}
 function isPlanExecBatchPublication(value) {
     if (value === undefined)
         return true;
@@ -1587,6 +2031,7 @@ function isPlanExecBatchTraceArray(value, batches) {
             typeof entry.iteration === "number" &&
             Number.isInteger(entry.iteration) &&
             typeof entry.transition === "string" &&
+            (entry.approval === undefined || entry.approval === true) &&
             entry.transition.length > 0 &&
             PLAN_EXEC_BATCH_STAGES.includes(entry.stage) &&
             (entry.kind === "entered" || entry.kind === "completed" || entry.kind === "blocked"));
@@ -1744,7 +2189,13 @@ function isFixPreview(value) {
     return (typeof value.intent === "string" &&
         value.intent.trim().length > 0 &&
         typeof value.diff === "string" &&
-        value.diff.trim().length > 0);
+        value.diff.trim().length > 0 &&
+        isQuickCheckouts(value.checkouts));
+}
+function isQuickCheckouts(value) {
+    return (value === null ||
+        value === undefined ||
+        (isRecord(value) && Object.values(value).every(nonEmpty)));
 }
 function isDecisionPreview(value, baseline) {
     if (!isRecord(value) ||
@@ -1862,10 +2313,8 @@ function isEvent(entry) {
         return false;
     if (typeof entry.transition !== "string" || typeof entry.operation !== "string")
         return false;
-    if (entry.batch_iteration !== undefined &&
-        (!Number.isInteger(entry.batch_iteration) || entry.batch_iteration < 1)) {
+    if (!isIterationRecord(entry))
         return false;
-    }
     return EVENT_BODIES.get(entry.kind)?.(entry) === true;
 }
 const nonEmpty = (value) => typeof value === "string" && value.trim().length > 0;
@@ -1880,6 +2329,9 @@ const EVENT_BODIES = new Map(Object.entries({
         isEffectClassArray(entry.effects) &&
         isStringArray(entry.evidence),
     reconciled: (entry) => isRepairArray(entry.repairs),
+    retracted: (entry) => nonEmpty(entry.signal) &&
+        isObservationArray(entry.observations) &&
+        entry.observations.length > 0,
     restarted: (entry) => nonEmpty(entry.archive) && nonEmpty(entry.cause),
     annulled: (entry) => isStringArray(entry.batches) &&
         entry.batches.length > 0 &&
@@ -1888,6 +2340,7 @@ const EVENT_BODIES = new Map(Object.entries({
         isStringArray(entry.tasks) &&
         nonEmpty(entry.digest),
     aligned: (entry) => Number.isInteger(entry.position) && entry.position >= 0 && nonEmpty(entry.reason),
+    "route-refused": (entry) => isRouteDisposition(entry.disposition) && nonEmpty(entry.reason),
     failed: (entry) => typeof entry.code === "string" &&
         typeof entry.message === "string" &&
         typeof entry.recovery === "string" &&
@@ -1913,8 +2366,40 @@ function isObservationArray(value) {
     return value.every((entry) => isRecord(entry) &&
         typeof entry.transition === "string" &&
         isStringArray(entry.signals) &&
-        (entry.batch_iteration === undefined ||
-            (Number.isInteger(entry.batch_iteration) && entry.batch_iteration >= 1)));
+        isIterationRecord(entry));
+}
+const REENTRY_KINDS = ["refine", "close", "reopen", "review", "reinfer"];
+/** Absent, or reentries each with its kind, its boundary, its occurrence and its origin. */
+function isReentryArray(value) {
+    if (value === undefined)
+        return true;
+    if (!Array.isArray(value))
+        return false;
+    return value.every((entry) => isRecord(entry) &&
+        REENTRY_KINDS.includes(entry.kind) &&
+        (entry.kind !== "review" ||
+            (entry.transition === "plan-exec.batch-close" &&
+                entry.from === "plan-exec.review-findings")) &&
+        (entry.kind !== "reinfer" ||
+            (entry.from === "plan-exec.validation-execution" &&
+                [
+                    "plan-exec.deferred-check",
+                    "plan-exec.review-findings",
+                    "plan-exec.batch-commit-proposal",
+                    "plan-exec.batch-close",
+                ].includes(entry.transition))) &&
+        nonEmpty(entry.transition) &&
+        Number.isInteger(entry.occurrence) &&
+        entry.occurrence >= 1 &&
+        // A redraft names where it re-enters; the other kinds repeat from their row.
+        (entry.kind === "refine"
+            ? nonEmpty(entry.from)
+            : entry.from === null || nonEmpty(entry.from)));
+}
+/** Both iteration fields, each absent or a positive integer. */
+function isIterationRecord(entry) {
+    const ordinal = (value) => value === undefined || (Number.isInteger(value) && value >= 1);
+    return ordinal(entry.batch_iteration) && ordinal(entry.reentry_iteration);
 }
 /**
  * The two optional fields are checked as ABSENT-or-well-formed, never defaulted.
@@ -1950,8 +2435,7 @@ function isAttemptArray(value) {
         Number.isInteger(entry.attempt) &&
         typeof entry.request_digest === "string" &&
         typeof entry.transition === "string" &&
-        (entry.batch_iteration === undefined ||
-            (Number.isInteger(entry.batch_iteration) && entry.batch_iteration >= 1)) &&
+        isIterationRecord(entry) &&
         (entry.parent_request_digest === null || typeof entry.parent_request_digest === "string"));
 }
 //# sourceMappingURL=run-state.js.map