loopforge 3.9.2 → 4.0.7

package/dist/committed-round.js

@@ -4,12 +4,16 @@
  * place that interprets their transaction envelope or the compiler's merged
  * lineage representation. Consumers receive one stable, read-only view.
  */
-import { GIT_OBSERVATION_SCHEMA_VERSION, PROMPT_ARTIFACT_SCHEMA_VERSION, } from "./protocol.js";
-import { ROUND_TRANSACTION_SCHEMA_VERSION, deriveRoundObservationDelta, parseRoundTransactionSnapshot, transactionSchemaVersionOf, } from "./round-transaction.js";
-import { claimedMetCriteria, claimedRemainingCriteria, effectiveOutcome, parseRoundContract } from "./self-eval.js";
+import { observationVersionIssue } from "./evidence-provider.js";
+import { promptContextPairIssue } from "./context-boundary.js";
+import { PROMPT_ARTIFACT_SCHEMA_VERSION, isPromptContextMode, isPromptContextReason, makeLoopRoundResult, } from "./protocol.js";
+import { ROUND_TRANSACTION_SCHEMA_VERSION, deriveRoundObservationDelta, isProcessResult, parseRoundTransactionSnapshot, rootBranchId, transactionSchemaVersionOf, } from "./round-transaction.js";
+import { effectiveOutcome, parseRoundContract, } from "./self-eval.js";
 import { entryRound, isRecord } from "./token-utils.js";
+import { transactionIdentityIssue } from "./transaction-identity.js";
 function committedAction(value) {
-    return value === "continue" || value === "stop" || value === "backtrack"
+    return value === "continue" || value === "stop" ||
+        value === "recovery" || value === "backtrack"
         ? value
         : null;
 }
@@ -19,56 +23,11 @@ function snapshots(value) {
 function flags(value) {
     return Array.isArray(value) ? value : [];
 }
-function roundOutcome(value) {
-    return value === "success" || value === "partial" ||
-        value === "failed" || value === "blocked"
-        ? value
-        : null;
-}
 function strings(value) {
     return Array.isArray(value)
         ? value.filter((item) => typeof item === "string")
         : [];
 }
-function numbers(value) {
-    return Array.isArray(value)
-        ? value.filter((item) => typeof item === "number")
-        : [];
-}
-function stringMap(value) {
-    if (!isRecord(value))
-        return {};
-    const out = {};
-    for (const [key, entry] of Object.entries(value)) {
-        if (typeof entry === "string")
-            out[key] = entry;
-    }
-    return out;
-}
-/** v3.8.1: decode a rollback directive's facts from either carrier —
- *  `result.*` on a durable :feedback entry, `lineage.*` on a hydrated merged
- *  entry. Returns null when no restore point is recorded, which is also the
- *  signal that the record cannot serve as recovery guidance. */
-export function decodeBacktrackRecord(source) {
-    const value = isRecord(source) ? source : {};
-    const target = typeof value.backtrackTarget === "number" ? value.backtrackTarget : null;
-    if (target === null)
-        return null;
-    return {
-        target,
-        triggerRule: typeof value.backtrackTriggerRule === "string"
-            ? value.backtrackTriggerRule
-            : "",
-        failedRounds: numbers(value.backtrackFailedRounds),
-        approaches: strings(value.backtrackApproaches),
-        wrongAssumptions: strings(value.backtrackWrongAssumptions),
-        skippedFiles: strings(value.backtrackSkippedFiles),
-        skippedFingerprints: stringMap(value.backtrackSkippedFingerprints),
-        targetGitHead: typeof value.backtrackTargetGitHead === "string"
-            ? value.backtrackTargetGitHead
-            : undefined,
-    };
-}
 /** Normalize a raw subgoal_updates value into typed entries. Decode stays
  *  tolerant of any shape (parser caps apply at ingestion; this is the
  *  read-model view of what was committed). */
@@ -114,7 +73,7 @@ function evidenceIncomplete(after, deltas) {
  *  feedback entry and the engine's hydrated merged entry call it, so there is
  *  no second evaluation/history interpretation. */
 function viewFromSnapshot(input) {
-    const { snapshot, result, lineage } = input;
+    const { snapshot, result } = input;
     if (snapshot.phase !== "committed")
         return null;
     const action = committedAction(result.action);
@@ -129,12 +88,27 @@ function viewFromSnapshot(input) {
     const beforeEvidence = snapshots(snapshot.beforeEvidence);
     const afterEvidence = snapshots(snapshot.afterEvidence);
     const observationDelta = deriveRoundObservationDelta(beforeEvidence, afterEvidence);
+    const contractProposal = evaluation?.round_contract
+        ? parseRoundContract(evaluation.round_contract) ?? null
+        : null;
     return {
         source: input.source,
         sourceEntry: input.sourceEntry,
         loopId,
         round,
         roundId: snapshot.roundId,
+        transactionId: snapshot.transactionId,
+        branchId: snapshot.branchId,
+        kind: snapshot.kind,
+        origin: snapshot.kind === "rollback"
+            ? (snapshot.recovery?.origin ?? "machine")
+            : "evaluation",
+        recovery: snapshot.recovery ?? null,
+        beforeCheckpoint: snapshot.beforeCheckpoint ?? null,
+        checkpoints: snapshot.checkpoints ?? [],
+        restore: snapshot.restore ?? null,
+        operatorAcceptance: snapshot.operatorAcceptance ?? null,
+        compiled: snapshot.compiled ?? null,
         sequence: input.sequence,
         attempt: snapshot.attempt,
         promptArtifact: snapshot.promptArtifact ?? null,
@@ -142,12 +116,16 @@ function viewFromSnapshot(input) {
         executionReport: evaluation?.execution_report ?? null,
         verificationFlags: flags(result.verificationFlags),
         result,
+        evidencePosture: result.evidencePosture ?? null,
         action,
-        success: result.roundSuccess === true,
-        outcome,
-        contractProposal: evaluation?.round_contract
-            ? parseRoundContract(evaluation.round_contract) ?? null
-            : null,
+        agentSuccessClaim: result.agentSuccessClaim === true,
+        agentOutcome: result.agentOutcome ?? outcome,
+        ...(evaluation && typeof evaluation.objective_refinement === "string" &&
+            evaluation.objective_refinement.trim().length > 0
+            ? { objectiveRefinement: evaluation.objective_refinement }
+            : {}),
+        contractProposal,
+        contractRedirect: contractProposal?.supersedes ?? null,
         contractBinding: snapshot.contractBinding ?? null,
         beforeEvidence,
         afterEvidence,
@@ -158,13 +136,17 @@ function viewFromSnapshot(input) {
         outputSummary: evaluation?.output_summary,
         constraintViolations: strings(evaluation?.constraint_violations),
         discoveredConstraints: strings(evaluation?.discovered_constraints),
-        activeConstraints: strings(lineage?.constraints_active),
+        activeConstraints: snapshot.compiled
+            ? [...snapshot.compiled.constraintsActive]
+            : [],
+        compiledRetirements: snapshot.compiled
+            ? [...snapshot.compiled.constraintsRetired]
+            : [],
         retractedConstraints: strings(evaluation?.retracted_constraints),
+        openQuestions: strings(evaluation?.open_questions),
+        resolvedOpenQuestionIds: strings(evaluation?.resolved_open_question_ids),
         emergedSubtasks: strings(evaluation?.emerged_subtasks),
         subgoalUpdates: subGoalUpdates(evaluation?.subgoal_updates),
-        backtrack: action === "backtrack"
-            ? decodeBacktrackRecord(result)
-            : null,
     };
 }
 export function decodeCommittedRound(entry) {
@@ -181,66 +163,107 @@ export function decodeCommittedRound(entry) {
     // legacyTransactionRounds() reports the loss explicitly; it is never
     // silently decoded into a partial view.
     const snapshot = parseRoundTransactionSnapshot(transaction.snapshot);
-    if (!snapshot)
+    if (!snapshot || snapshot.kind !== "evaluation")
+        return null;
+    const identityIssue = transactionIdentityIssue(entry);
+    if (identityIssue)
         return null;
     const resultValue = isRecord(transaction.result)
         ? transaction.result
         : snapshot.result;
-    if (!isRecord(resultValue))
+    // v4.0.3/v4.0.6: a current-schema (9) committed result must carry a
+    // well-formed Evidence Posture and a well-formed Agent outcome. A missing or
+    // corrupt posture/result is a HARD break, never re-derived at read time.
+    if (!isRecord(resultValue) || !isProcessResult(resultValue))
         return null;
     return viewFromSnapshot({
         source: "feedback",
         sourceEntry: entry,
-        lineage,
         snapshot,
         result: resultValue,
         sequence: typeof entry.sequence === "number" ? entry.sequence : undefined,
     });
 }
-/** Decode an in-memory lineage entry after the engine merged its committed
- * feedback. The merged entry MUST carry the embedded transaction snapshot;
- * the old raw top-level evaluation reconstruction is gone, so a partial
- * lineage entry cannot become a second history. */
-export function decodeMergedRound(entry) {
-    if (!isRecord(entry))
+/** v3.9.6: decode a committed rollback directive event. It is a typed event
+ *  in the round document, never a normal feedback round. */
+export function decodeRollbackEvent(entry) {
+    if (entry.task_type !== "rollback_directive")
         return null;
-    const raw = entry;
-    const lineage = isRecord(raw.loop_lineage) ? raw.loop_lineage : {};
-    const action = committedAction(lineage.committed_action ?? raw.committed_action);
-    if (!action)
-        return null;
-    const transaction = isRecord(lineage.round_transaction)
+    const lineage = isRecord(entry.loop_lineage) ? entry.loop_lineage : null;
+    const transaction = lineage && isRecord(lineage.round_transaction)
         ? lineage.round_transaction
-        : isRecord(raw.round_transaction)
-            ? raw.round_transaction
-            : null;
+        : null;
     if (!transaction)
         return null;
     const snapshot = parseRoundTransactionSnapshot(transaction.snapshot);
-    if (!snapshot)
+    if (!snapshot || snapshot.kind !== "rollback" || !snapshot.recovery)
+        return null;
+    const identityIssue = transactionIdentityIssue(entry);
+    if (identityIssue)
         return null;
     const resultValue = isRecord(transaction.result)
         ? transaction.result
         : snapshot.result;
-    if (!isRecord(resultValue))
+    if (!isRecord(resultValue) || !isProcessResult(resultValue))
+        return null;
+    const result = resultValue;
+    if (result.action !== "recovery" && result.action !== "backtrack")
         return null;
     return viewFromSnapshot({
-        source: "merged",
-        sourceEntry: raw,
-        lineage,
+        source: "rollback",
+        sourceEntry: entry,
         snapshot,
-        result: resultValue,
-        sequence: typeof lineage.sequence === "number" ? lineage.sequence : undefined,
+        result,
+        sequence: typeof entry.sequence === "number" ? entry.sequence : undefined,
     });
 }
 /** Normalize committed history: rollback directives disappear, later records
  * replace earlier records for the same logical round, and output is ascending. */
-/** Decode a committed round from either representation: an engine-hydrated
- *  merged lineage entry first (decodeMergedRound), then a durable :feedback
- *  entry. Compile-side callers used to inline this chain as a private
- *  `committedView` helper. */
-export function decodeRound(entry) {
-    return decodeMergedRound(entry) ?? decodeCommittedRound(entry);
+/** v4.0.1: decode either an ordinary committed round or a rollback event.
+ *  There is no merged-lineage representation any more: a committed round is
+ *  exactly its durable :feedback envelope, and a rollback is its event. */
+export function decodeCommittedRecord(entry) {
+    return decodeCommittedRound(entry) ??
+        decodeRollbackEvent(entry);
+}
+/** THE committed-view → compiler-request projection.
+ *
+ *  The compiler once received these fields from the caller's mutable
+ *  `last_round_result`, which existed on the live path and was absent on
+ *  resume/unpause/backtrack compiles. This projection lets one committed
+ *  fact source feed every consumer. Optional declarations are read from the
+ *  decoded view where it exposes them. */
+export function roundResultFromCommittedRound(view) {
+    const evaluation = view.evaluation;
+    return makeLoopRoundResult({
+        round: view.round,
+        agentSuccessClaim: view.agentSuccessClaim,
+        output_summary: evaluation?.output_summary ?? "",
+        constraint_violations: [...(evaluation?.constraint_violations ?? [])],
+        discovered_constraints: [...(view.discoveredConstraints ?? [])],
+        emerged_subtasks: [...(view.emergedSubtasks ?? [])],
+        subgoal_updates: [...(view.subgoalUpdates ?? [])],
+        execution_report: view.executionReport ?? undefined,
+        retracted_constraints: [...(view.retractedConstraints ?? [])],
+        wrong_assumptions: [...(evaluation?.wrong_assumptions ?? [])],
+        open_questions: [...(evaluation?.open_questions ?? [])],
+        resolved_open_question_ids: [...(evaluation?.resolved_open_question_ids ?? [])],
+        worker_results: [...(evaluation?.worker_results ?? [])],
+        subtask_boundary: evaluation?.subtask_boundary === true,
+        subtask_boundary_label: evaluation?.subtask_boundary_label ?? "",
+        agentOutcome: evaluation
+            ? effectiveOutcome(evaluation)
+            : view.agentOutcome ?? undefined,
+        blocker: evaluation?.blocker,
+        retroactiveClaims: [...(evaluation?.retroactiveClaims ?? [])],
+        no_change_reason: evaluation?.no_change_reason,
+    });
+}
+/** The ONE pending-directive lookup for a redo round. The directive's
+ *  `target.redo_round` is the branch fence, so a deep restore and a
+ *  same-round redo match the same way. */
+export function pendingBacktrackRecord(entries, redoRound) {
+    return pendingRollbackDirective(entries, redoRound);
 }
 /** Lineage sub-object of an entry (`loop_lineage`; v3.7: the legacy
  *  top-level `lineage` alias was removed), or {} when absent. */
@@ -250,188 +273,114 @@ export function entryLineage(entry) {
     const value = entry.loop_lineage;
     return isRecord(value) ? value : {};
 }
-/** Extract execution_report from an entry, handling both direct-field and
- *  lineage-nested shapes. The decoded committed view wins when the entry is
- *  a committed round. Returns null when absent. Moved from loop-compiler so
- *  field-shape interpretation lives in this module only. */
-export function entryExecutionReport(entry) {
-    const view = decodeRound(entry);
-    if (view)
-        return view.executionReport;
-    const record = isRecord(entry) ? entry : {};
-    const direct = record.execution_report;
-    if (isRecord(direct))
-        return direct;
-    const nested = entryLineage(entry).execution_report;
-    return isRecord(nested) ? nested : null;
-}
-/** Read the criteria the agent claimed met from an entry's execution_report. */
-export function entryCriteriaMet(entry) {
-    const view = decodeRound(entry);
-    if (view)
-        return claimedMetCriteria(view.executionReport);
-    const ev = entryExecutionReport(entry);
-    if (!ev)
-        return [];
-    return rawCriterionClaims(ev, "met");
-}
-/** Read the criteria the agent declared outstanding from an entry. */
-export function entryCriteriaRemaining(entry) {
-    const view = decodeRound(entry);
-    if (view)
-        return claimedRemainingCriteria(view.executionReport);
-    const ev = entryExecutionReport(entry);
-    if (!ev)
-        return [];
-    return rawCriterionClaims(ev, "remaining");
-}
-/** Shape-tolerant reader for a raw entry's criterion claims (the durable
- *  shape, before the typed parse). */
-function rawCriterionClaims(report, outcome) {
-    const claims = report.criterion_claims;
-    if (!Array.isArray(claims))
-        return [];
-    return claims
-        .filter(isRecord)
-        .filter((claim) => claim.outcome === outcome && typeof claim.criterion_id === "string")
-        .map((claim) => claim.criterion_id);
-}
-/** Read constraints_active from an entry's lineage. */
-export function entryActiveConstraints(entry) {
-    const view = decodeRound(entry);
-    if (view)
-        return view.activeConstraints ?? [];
-    const arr = entryLineage(entry).constraints_active;
-    return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
-}
-/** Read retracted_constraints from an entry (direct field, else nested in
- *  the lineage). */
-export function entryRetractedConstraints(entry) {
-    const view = decodeRound(entry);
-    if (view)
-        return view.retractedConstraints ?? [];
-    const record = isRecord(entry) ? entry : {};
-    const direct = record.retracted_constraints;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    const nested = entryLineage(entry).retracted_constraints;
-    if (Array.isArray(nested))
-        return nested.filter((v) => typeof v === "string");
-    return [];
-}
-/** Read emerged_subtasks from an entry (handles direct + lineage nesting). */
-export function entryEmergedSubtasks(entry) {
-    const view = decodeRound(entry);
-    if (view)
-        return view.emergedSubtasks ?? [];
-    const record = isRecord(entry) ? entry : {};
-    const direct = record.emerged_subtasks;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    const nested = entryLineage(entry).emerged_subtasks;
-    if (Array.isArray(nested))
-        return nested.filter((v) => typeof v === "string");
-    return [];
-}
-/** Read subgoal_updates from an entry (handles direct + lineage nesting).
- *  v3.7.1: committed status transitions are replayed in round order by the
- *  compiler — every derivation replays ALL committed rounds, not just the
- *  last one. */
-export function entrySubGoalUpdates(entry) {
-    const view = decodeRound(entry);
-    if (view)
-        return view.subgoalUpdates ?? [];
-    const record = isRecord(entry) ? entry : {};
-    const direct = record.subgoal_updates;
-    if (Array.isArray(direct))
-        return subGoalUpdates(direct);
-    const nested = entryLineage(entry).subgoal_updates;
-    if (Array.isArray(nested))
-        return subGoalUpdates(nested);
-    return [];
-}
-/** Read constraint_violations from an entry (entry-level, stored from the
- *  previous round's last_round_result at persist time — distinct from the
- *  evaluation-level violations on the committed view). Moved from
- *  verification-gate so lineage-shape reads live in this module only. */
-export function entryViolations(entry) {
-    const record = isRecord(entry) ? entry : {};
-    const viols = record.constraint_violations;
-    if (Array.isArray(viols))
-        return viols.filter((v) => typeof v === "string");
-    return [];
-}
-export function historyRounds(views, beforeRound = Number.POSITIVE_INFINITY) {
+/** Resolve the current branch from already-decoded committed views. This is
+ *  the branch walker itself; `resolveBranch` is only the entry-decoding
+ *  wrapper, so a caller that already holds the views (the history loader)
+ *  never decodes the same entries twice. */
+export function resolveBranchViews(records) {
+    const kindOf = (view) => view.kind ?? "evaluation";
+    const first = records.find((view) => kindOf(view) === "evaluation") ?? records[0];
+    if (!first) {
+        return { loopId: "", branchId: "", rounds: [], directives: [], pendingDirective: null };
+    }
+    const loopId = first.loopId;
+    const branchOf = (view) => view.branchId ?? rootBranchId(loopId);
+    let branchId = rootBranchId(loopId);
+    let rounds = records
+        .filter((view) => kindOf(view) === "evaluation" && branchOf(view) === branchId)
+        .sort((a, b) => a.round - b.round);
+    const directives = [];
+    const seen = new Set();
+    for (;;) {
+        const candidates = records
+            .filter((view) => kindOf(view) === "rollback" &&
+            branchOf(view) === branchId &&
+            view.recovery !== null && view.recovery !== undefined)
+            .sort((a, b) => a.round - b.round ||
+            (a.transactionId ?? "").localeCompare(b.transactionId ?? ""));
+        if (candidates.length === 0)
+            break;
+        // A branch closes exactly once. If corrupt data has more, the latest one
+        // is the effective directive; the others remain visible in the raw log.
+        const directive = candidates[candidates.length - 1];
+        const directiveId = directive.transactionId ?? directive.roundId;
+        if (seen.has(directiveId))
+            break;
+        seen.add(directiveId);
+        const recovery = directive.recovery;
+        // v3.9.7: the fence is the explicit redo round, not a nominal target
+        // round. A before/mid checkpoint's redo round is its owning round.
+        rounds = rounds.filter((view) => view.round < recovery.target.redo_round);
+        const child = recovery.transaction_id;
+        const childRounds = records
+            .filter((view) => kindOf(view) === "evaluation" && branchOf(view) === child)
+            .sort((a, b) => a.round - b.round);
+        rounds = [...rounds, ...childRounds];
+        directives.push(directive);
+        branchId = child;
+    }
     const byRound = new Map();
-    for (const view of views) {
-        if (!view || view.action === "backtrack" || view.round >= beforeRound)
-            continue;
+    for (const view of rounds)
         byRound.set(view.round, view);
+    rounds = [...byRound.values()].sort((a, b) => a.round - b.round);
+    let pendingDirective = null;
+    const latest = directives[directives.length - 1];
+    if (latest && latest.recovery) {
+        const child = latest.recovery.transaction_id;
+        const hasChildRound = records.some((view) => kindOf(view) === "evaluation" && branchOf(view) === child);
+        if (!hasChildRound)
+            pendingDirective = latest;
+    }
+    return { loopId, branchId, rounds, directives, pendingDirective };
+}
+/** Resolve the current branch from committed records in the raw entry view.
+ *  Decoding happens once here; the walker itself is `resolveBranchViews`. */
+export function resolveBranch(entries) {
+    return resolveBranchViews(entries
+        .map(decodeCommittedRecord)
+        .filter((view) => view !== null));
+}
+/** v3.9.6: current-branch evaluation rounds. */
+export function branchRounds(entries) {
+    return resolveBranch(entries).rounds;
+}
+/** v3.9.6: rollback directive chain. */
+export function branchDirectives(entries) {
+    return resolveBranch(entries).directives;
+}
+/** v3.9.6: the pending directive controlling a redo round. */
+export function pendingRollbackDirective(entries, redoRound) {
+    const pending = resolveBranch(entries).pendingDirective;
+    if (!pending?.recovery)
+        return null;
+    if (redoRound !== undefined && pending.recovery.target.redo_round !== redoRound) {
+        return null;
     }
-    return [...byRound.values()].sort((a, b) => a.round - b.round);
+    return pending;
+}
+/** v3.9.6: machine deadlock guard. Agent-origin directives never consume it. */
+export function hasCommittedMachineBacktrack(entries, currentRound) {
+    return branchDirectives(entries).some((view) => {
+        const recovery = view.recovery;
+        return view.origin === "machine" &&
+            recovery !== null && recovery !== undefined &&
+            recovery.target.redo_round <= currentRound &&
+            view.round >= currentRound;
+    });
 }
-/** v3.8.1: the ONE committed-history window every derivation reads.
- *
- * `decodeRound` (hydrated merged lineage first, then the durable feedback
- * entry) plus the rollback handling in `historyRounds` — so the compile path,
- * the projection, the live coordinator, audit and explain can no longer
- * disagree about which rounds are this branch's history, nor about how their
- * envelope was interpreted.
- *
- * `currentRound` bounds the window exactly as before (default: unbounded). It
- * is NOT a rollback fence: the redo re-commits the round numbers the abandoned
- * rounds occupied, so abandonment is temporal, not numeric, and cannot be
- * expressed as a bound here. */
+/** v3.9.6: live history window = current branch below the round being
+ *  compiled. `currentRound` is the round being prepared/submitted. */
 export function derivationRounds(entries, currentRound = Number.POSITIVE_INFINITY) {
-    return historyRounds(entries.map(decodeRound), currentRound);
-}
-/** v3.8.1: the loop's durable round frontier — the session document's
- *  `current_round`. Null when no session document is in the entry set, so
- *  callers fail OPEN rather than inventing a bound. */
-export function persistedFrontier(entries) {
-    for (const entry of entries) {
-        if (!isRecord(entry) || entry.task_type !== "session_state")
-            continue;
-        const round = entryLineage(entry).current_round;
-        return typeof round === "number" && Number.isFinite(round) && round >= 1
-            ? round
-            : null;
-    }
-    return null;
+    return branchRounds(entries).filter((view) => view.round < currentRound);
 }
-/** v3.8.1: THE window for a READ-ONLY view of a loop — audit, explain, replay,
- *  the projection, the metrics replay. Same decoder and same rollback handling
- *  as `derivationRounds`, plus the bound those callers cannot compute
- *  themselves.
- *
- *  The live paths bound their window at the round being compiled, and that
- *  bound is what keeps a backtracked branch out of this branch's history. A
- *  read-only view has no compile round, so it reads the SAME frontier from the
- *  durable session document and applies it only while a committed rollback
- *  directive is still in effect — a directive stops being history the moment
- *  the redo commit replaces its round's record, which is exactly when the
- *  abandoned rounds have been re-committed and must count again.
- *
- *  With no directive in effect the window stays UNBOUNDED on purpose: after a
- *  stop, terminate or max_rounds the session's `current_round` sits ON the
- *  round it just committed, so bounding there would silently drop the loop's
- *  final round. An unobservable frontier fails open the same way — a read-only
- *  view never invents a fence, it only applies the one the runtime recorded. */
+/** v3.9.6: read-only history = current branch rounds. No session frontier,
+ *  no numeric fence, no second cursor. */
 export function readOnlyRounds(entries) {
-    const views = entries.map(decodeRound);
-    const rollbackPending = views.some((view) => view?.action === "backtrack");
-    if (!rollbackPending)
-        return historyRounds(views);
-    return historyRounds(views, persistedFrontier(entries) ?? Number.POSITIVE_INFINITY);
+    return branchRounds(entries);
 }
-/** The machine-evidence set that best represents a committed round: the
- *  after-phase observations (captured post-execution), else the pre-round
- *  baseline. The derived delta is never evidence — it is a change-set view
- *  over these facts, not a second observation collection. */
-export function machineEvidenceForRound(view) {
-    if (view.afterEvidence.length > 0)
-        return view.afterEvidence;
-    return view.beforeEvidence;
+/** v3.9.6: read-only rollback events = committed directive chain. */
+export function readOnlyRollbacks(entries) {
+    return branchDirectives(entries);
 }
 export function legacyTransactionRounds(entries) {
     const out = [];
@@ -459,12 +408,42 @@ export function legacyTransactionRounds(entries) {
         // silently, which is the one thing this function exists to prevent.
         const snapshot = envelope.snapshot;
         if (isRecord(snapshot.promptArtifact)) {
-            const artifactVersion = snapshot.promptArtifact.schemaVersion;
+            const artifact = snapshot.promptArtifact;
+            const artifactVersion = artifact.schemaVersion;
             if (typeof artifactVersion === "number" &&
                 artifactVersion !== PROMPT_ARTIFACT_SCHEMA_VERSION) {
                 out.push({ round, schemaVersion: artifactVersion, envelope: "prompt_artifact" });
                 continue;
             }
+            // v4.0.5: the same runtime whitelists the decoder uses. A malformed
+            // optional invocation instruction is a legacy artifact, not accepted
+            // silently.
+            const validInstruction = artifact.currentUserInstruction === undefined ||
+                (typeof artifact.currentUserInstruction === "string" &&
+                    artifact.currentUserInstruction.trim().length > 0);
+            const validContextFields = (artifact.level === "l0" || artifact.level === "l1" || artifact.level === "l2") &&
+                isPromptContextMode(artifact.contextMode) &&
+                isPromptContextReason(artifact.contextReason) &&
+                validInstruction &&
+                typeof artifact.attempt === "number" &&
+                typeof artifact.round === "number";
+            const contextIssue = validContextFields
+                ? promptContextPairIssue({
+                    level: artifact.level,
+                    mode: artifact.contextMode,
+                    reason: artifact.contextReason,
+                    attempt: artifact.attempt,
+                    round: artifact.round,
+                })
+                : "missing or malformed context boundary fields";
+            if (contextIssue !== null) {
+                out.push({
+                    round,
+                    schemaVersion: typeof artifactVersion === "number" ? artifactVersion : -1,
+                    envelope: "prompt_context",
+                });
+                continue;
+            }
         }
         // v3.9.1: an observation schema mismatch is also a hard break. The
         // transaction parser drops the whole round on it; report the loss here
@@ -474,16 +453,16 @@ export function legacyTransactionRounds(entries) {
             ...(Array.isArray(snapshot.afterEvidence) ? snapshot.afterEvidence : []),
         ];
         for (const item of observations) {
-            if (!isRecord(item) || typeof item.kind !== "string") {
+            if (!isRecord(item)) {
                 out.push({ round, schemaVersion: -1, envelope: "observation" });
                 break;
             }
-            const expected = item.kind === "git" ? GIT_OBSERVATION_SCHEMA_VERSION : 1;
-            const observationVersion = item.schemaVersion;
-            if (typeof observationVersion !== "number" || observationVersion !== expected) {
+            // v3.9.9: the SAME version judgment the transaction parser uses.
+            const issue = observationVersionIssue(item.kind, item.schemaVersion, item.data, item.status);
+            if (issue) {
                 out.push({
                     round,
-                    schemaVersion: typeof observationVersion === "number" ? observationVersion : -1,
+                    schemaVersion: issue.schemaVersion,
                     envelope: "observation",
                 });
                 break;
@@ -492,106 +471,4 @@ export function legacyTransactionRounds(entries) {
     }
     return out.sort((a, b) => a.round - b.round);
 }
-/** The ONE definition of machine Git motion for a single round.
- *
- *  Motion is a non-empty file list, a HEAD that moved across the round, or a
- *  HEAD that landed on the rollback's restore point — restoring the workspace
- *  IS that round's work, and would otherwise read as a round that did
- *  nothing. A clean worktree is not the same thing as no progress:
- *  commit-per-slice workflows leave no file delta even though HEAD advanced.
- *
- *  Observability stays the caller's concern: this answers "did this round
- *  move", never "could the round be observed". The restore-point arm compares
- *  short hashes, the rule `checkBacktrackGitHeadRestore` uses; the
- *  before/after arm compares the observations themselves. */
-export function gitMotionSignal(input) {
-    if (input.changedFiles !== null && input.changedFiles.length > 0)
-        return true;
-    const { headBefore, headAfter, restoreTargetHead } = input;
-    if (headAfter && headBefore && headAfter !== headBefore)
-        return true;
-    if (headAfter && restoreTargetHead &&
-        headAfter.slice(0, 12) === restoreTargetHead.slice(0, 12))
-        return true;
-    if (input.changedFiles === null)
-        return null;
-    // An observed empty change set is no motion only when both HEADs are known;
-    // otherwise a commit-only slice could still have moved HEAD.
-    if (!headBefore || !headAfter)
-        return null;
-    return false;
-}
-/** Git HEAD as a machine observation exposes it, or null when it is silent. */
-export function observedGitHead(observation) {
-    return observation && isRecord(observation.data) &&
-        typeof observation.data.head === "string" && observation.data.head
-        ? observation.data.head
-        : null;
-}
-function observedGitObservation(observation) {
-    return observation && observation.kind === "git" && observation.status === "observed"
-        ? observation
-        : null;
-}
-function observedGitIn(observations) {
-    return observations.find((observation) => observation.kind === "git" && observation.status === "observed") ?? null;
-}
-/** The in-flight round's own motion, from its derived Git delta. A Git
- *  boundary that cannot be compared yields `null` unless HEAD movement or the
- *  restore point independently proves motion. */
-export function inFlightGitMotion(deltas, restoreTargetHead) {
-    const git = deltas.find((delta) => delta.kind === "git");
-    if (!git)
-        return null;
-    const before = observedGitObservation(git.before);
-    const after = observedGitObservation(git.after);
-    return gitMotionSignal({
-        changedFiles: git.changedFiles,
-        headBefore: observedGitHead(before ?? undefined),
-        headAfter: observedGitHead(after ?? undefined),
-        restoreTargetHead: restoreTargetHead ?? null,
-    });
-}
-/** Machine-observed git motion for the most recent contiguous window.
- * A clean worktree is not the same thing as no progress: commit-per-slice
- * workflows leave no file delta even though HEAD advanced. Unknown motion in
- * any round makes the window undecidable rather than falsely empty. */
-export function machineGitMotionSeries(rounds, currentRound, lookback) {
-    if (!Number.isInteger(lookback) || lookback < 1 || currentRound <= lookback)
-        return null;
-    const byRound = new Map();
-    for (const round of rounds) {
-        if (round.round < 1 || round.round >= currentRound)
-            continue;
-        byRound.set(round.round, round);
-    }
-    const recent = [];
-    for (let number = currentRound - lookback; number < currentRound; number++) {
-        const round = byRound.get(number);
-        if (!round)
-            return null;
-        if (!round.observationDelta.some((delta) => delta.kind === "git"))
-            return null;
-        recent.push(round);
-    }
-    const motion = [];
-    for (const round of recent) {
-        const git = round.observationDelta.find((delta) => delta.kind === "git");
-        // The round's baseline: its own before observation, else the previous
-        // round's after observation. Older Git observations do not carry a HEAD
-        // field; their change set is still a valid motion signal.
-        const baseline = observedGitObservation(git.before)
-            ?? observedGitIn(byRound.get(round.round - 1)?.afterEvidence ?? []);
-        const after = observedGitObservation(git.after);
-        const signal = gitMotionSignal({
-            changedFiles: git.changedFiles,
-            headBefore: observedGitHead(baseline ?? undefined),
-            headAfter: observedGitHead(after ?? undefined),
-        });
-        if (signal === null)
-            return null;
-        motion.push(signal);
-    }
-    return motion;
-}
 //# sourceMappingURL=committed-round.js.map