@tacuchi/agent-workflow-cli 25.8.0 → 26.0.0

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

@@ -27,6 +27,7 @@ import { isEffectClass, touchesTheWorld } from "../capability/effects.js";
 import { AttemptLedger } from "../capability/protocol.js";
 import { normalizeObligations, validateDecisionNote } from "../decision-note.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 = 13;
+export const FLOW_RUN_STATE_VERSION = 15;
 /**
  * The versions this CLI CONTINUES without adoption, newest first.
  *
@@ -58,7 +59,15 @@ export const FLOW_RUN_STATE_VERSION = 13;
  * 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, 12, 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.
  *
@@ -83,6 +92,13 @@ 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";
@@ -171,11 +187,27 @@ export function currentReentryIteration(state, transition) {
  */
 function spendAt(state, transition) {
     const iteration = iterationOf(state, transition);
-    const rows = state.attempts.filter((attempt) => attempt.transition === transition && sameIteration(attempt, iteration));
+    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.
@@ -190,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",
         });
@@ -268,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
@@ -277,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",
@@ -287,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",
@@ -327,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;
@@ -388,8 +423,7 @@ function unanswerableAt(state) {
     }
     return null;
 }
-export function recoveryBlockedAt(state, transition) {
-    const iteration = iterationOf(state, transition);
+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)
@@ -415,6 +449,7 @@ function declaresMaterialEffect(event) {
         event.kind === "aligned" ||
         event.kind === "route-refused" ||
         event.kind === "restarted" ||
+        event.kind === "retracted" ||
         event.kind === "annulled") {
         return false;
     }
@@ -454,6 +489,7 @@ export const PLAN_EXEC_BATCH_STAGES = [
     "deviation",
     "validating",
     "reviewing",
+    "batch-committing",
     "closed",
     "committing",
     "integrating",
@@ -708,9 +744,64 @@ export function withPlanExecBatchCredit(state, batchId, credit) {
         return state;
     return sealRunState({
         ...withoutSeal(state),
-        batches: batches.map((batch) => (batch.id === batchId ? { ...batch, credit } : batch)),
+        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 ?? [];
@@ -774,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",
@@ -849,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. */
@@ -894,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 });
@@ -914,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.
  *
@@ -1433,8 +1621,44 @@ function checkCommonRecordShape(parsed, invalid) {
     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;
@@ -1499,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)) {
@@ -1636,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) {
@@ -1658,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 ||
@@ -1671,7 +1910,14 @@ function isPlanExecBatchArray(value) {
                 entry.published_plan_digest !== entry.publication.after_plan_digest) ||
             !PLAN_EXEC_BATCH_STAGES.includes(entry.stage) ||
             !isSourceMap(entry.base, true) ||
-            !isSourceMap(entry.credit, false)) {
+            !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);
@@ -1679,6 +1925,67 @@ 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)
@@ -1724,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"));
@@ -1881,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) ||
@@ -2015,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 &&
@@ -2051,7 +2368,7 @@ function isObservationArray(value) {
         isStringArray(entry.signals) &&
         isIterationRecord(entry));
 }
-const REENTRY_KINDS = ["refine", "close", "reopen"];
+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)
@@ -2060,6 +2377,17 @@ function isReentryArray(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 &&