loopforge 3.9.2 → 3.9.4

package/dist/loop-compiler.js

@@ -7,7 +7,8 @@ import { createHash } from "node:crypto";
 import { deriveConfiguredCapability, getPolicy } from "./policy.js";
 import { AgentStatus, makeLoopCompileResponse, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, } from "./protocol.js";
 import { createCanonicalLoopState, renderCanonicalStateMarkdown, } from "./canonical-state.js";
-import { decodeBacktrackRecord, decodeRound, entryLineage, entryCriteriaMet, entryCriteriaRemaining, entryActiveConstraints, entryRetractedConstraints, machineGitMotionSeries, derivationRounds, } from "./committed-round.js";
+import { decodeRound, entryLineage, entryCriteriaMet, entryCriteriaRemaining, entryActiveConstraints, entryRetractedConstraints, pendingBacktrackRecord, roundResultFromCommittedRound, machineGitMotionSeries, derivationRounds, } from "./committed-round.js";
+import { derivePromptFreshness, UNKNOWN_PROMPT_FRESHNESS, } from "./prompt-freshness.js";
 import { NO_IN_FLIGHT_ROUND, deriveRoundFacts } from "./round-facts.js";
 import { recoveryBriefLines } from "./enforcement-gate.js";
 import { deriveSubGoals, duplicateEmergedDeclarations } from "./subgoal-state.js";
@@ -15,7 +16,7 @@ import { claimedMetCriteria, claimedRemainingCriteria } from "./self-eval.js";
 import { assemblePromptArtifact } from "./prompt-assembler.js";
 import { renderSelfEvalBlock, } from "./submission-guidance.js";
 import { decidePromptLevel, } from "./prompt-policy.js";
-import { criterionRefMatches, deriveCriterionId, deriveItemId, normalizeText, unique, entryRound, } from "./token-utils.js";
+import { criterionRefMatches, deriveCriterionId, deriveItemId, normalizeText, unique, uniqueNormalized, entryRound, } from "./token-utils.js";
 function contextEntries(context) {
     if (!context || !Array.isArray(context.results))
         return [];
@@ -82,8 +83,21 @@ export function getPreviousRound(loopId, round, context) {
             : typeof data.output_summary === "string" ? data.output_summary : "",
     };
 }
-function latestObjective(loopId, context) {
-    const candidates = loopEntries(loopId, context).reverse();
+function latestObjective(loopId, context,
+/** Exclusive compile-round bound. A deep-restore redo must never read the
+ *  abandoned branch's objective (and its rolled-back refinements). */
+beforeRound,
+/** v3.9.4: a round-1 same-round retry has no earlier committed objective.
+ *  Reading the prior compile of the SAME round recovers the initial
+ *  criteria supplied to `loopforge_start`. It is never enabled for a first
+ *  attempt or for later rounds, so it cannot read an abandoned branch. */
+includeRoundOne = false) {
+    const candidates = loopEntries(loopId, context)
+        .filter((entry) => {
+        const round = entryRound(entry);
+        return round >= 1 && (round < beforeRound || (includeRoundOne && round === 1));
+    })
+        .reverse();
     for (const entry of candidates) {
         const raw = entry.loop_objective;
         if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -107,8 +121,9 @@ function latestObjective(loopId, context) {
     }
     return null;
 }
-function evolveObjective(request, context) {
-    const current = request.loop_objective ?? latestObjective(request.loop_id, context) ??
+function evolveObjective(request, context, previous) {
+    const current = request.loop_objective ??
+        latestObjective(request.loop_id, context, request.round, request.round === 1 && (request.attempt ?? 1) > 1) ??
         makeLoopObjective({
             objective: request.task,
             success_criteria: ["Task goal achieved with verifiable evidence"],
@@ -116,7 +131,7 @@ function evolveObjective(request, context) {
             created_at_round: 1,
             loop_id: request.loop_id,
         });
-    const last = request.last_round_result;
+    const last = previous.result;
     const history = [...(current.refinement_history ?? [])];
     let objective = current.objective || request.task;
     let version = current.version ?? 1;
@@ -124,9 +139,9 @@ function evolveObjective(request, context) {
         const refinement = last.objective_refinement.trim();
         // M5: fold each refinement exactly once per persisted objective state.
         // A retry recompiles the same round against the same committed
-        // last_round_result; without this guard every retry attempt re-appends
-        // the refinement and inflates the version — the objective text and the
-        // state file grew "Refinement: X" once per attempt.
+        // previous-round projection; without this guard every retry attempt
+        // re-appends the refinement and inflates the version — the objective text
+        // and the state file grew "Refinement: X" once per attempt.
         if (!history.includes(refinement)) {
             history.push(refinement);
             objective = `${objective}\nRefinement: ${refinement}`;
@@ -139,56 +154,69 @@ function evolveObjective(request, context) {
         objective,
         version,
         refinement_history: history.slice(-getPolicy().evolution.max_objective_versions),
-        success_criteria: unique(current.success_criteria.map((item) => revisions.get(item) ?? item)),
-        hard_constraints: unique(current.hard_constraints),
+        // v3.9.4: one normalized-exact text, one cr-* identity. `unique` was
+        // trim-only, so case/whitespace variants survived as two entries that
+        // derived to the SAME criterion id.
+        success_criteria: uniqueNormalized(current.success_criteria
+            .filter((item) => typeof item === "string")
+            .map((item) => revisions.get(item) ?? item)),
+        hard_constraints: uniqueNormalized(current.hard_constraints),
         loop_id: request.loop_id,
     });
 }
-function evolveConstraints(request, objective, previous, context) {
-    const retired = unique(request.last_round_result?.retracted_constraints ?? []);
-    const retiredSet = new Set(retired);
-    const discovered = unique(request.last_round_result?.discovered_constraints ?? [])
+function evolveConstraints(request, objective, previous, windowRounds) {
+    const retired = unique(previous.result?.retracted_constraints ?? []);
+    // v3.9.4: a revised-away criterion text is no longer an objective criterion.
+    // It must not survive as a "discovered" active constraint just because the
+    // previous round's active set carried it. This is a merge-time suppression,
+    // not an alias and not a constraint retirement.
+    const revisedAway = unique((previous.result?.revised_success_criteria ?? []).map((item) => item.old));
+    const immediateRetired = new Set([...retired, ...revisedAway].map((text) => normalizeText(text)));
+    const discovered = unique(previous.result?.discovered_constraints ?? [])
         .slice(0, getPolicy().evolution.max_discovered_constraints_per_round);
     // v2.14: agent-declared retractions of plan/hard/criteria constraints
     // persist for constraints.retire_window rounds (they are re-merged from
     // the request/objective every round, so without this the documented
     // "Removed from the active constraint set" never held for them). The
-    // retraction rounds are derived from vault entries — no new persistence
-    // format. After the window the constraint returns (hard/plan/criteria
-    // constraints never auto-decay — only agent action removes them, and the
-    // action's memory expires).
+    // retraction rounds are derived from the SAME committed window as every
+    // other compile fact — an abandoned branch above the compile round can
+    // never suppress a constraint on the restored branch.
     const window = getPolicy().constraints.retire_window;
     const lastRetractedRound = new Map();
     if (window > 0) {
-        for (const entry of loopEntries(request.loop_id, context)) {
-            const retractedList = entryLineage(entry).retracted_constraints;
-            if (!Array.isArray(retractedList))
-                continue;
-            const rnd = entryRound(entry);
+        for (const round of windowRounds) {
+            const retractedList = round.retractedConstraints ?? [];
             for (const text of retractedList) {
-                if (typeof text !== "string" || !text)
+                if (!text)
                     continue;
-                const prev = lastRetractedRound.get(text);
-                if (prev === undefined || rnd > prev)
-                    lastRetractedRound.set(text, rnd);
+                const key = normalizeText(text);
+                const previousRound = lastRetractedRound.get(key);
+                if (previousRound === undefined || round.round > previousRound) {
+                    lastRetractedRound.set(key, round.round);
+                }
             }
         }
     }
-    const active = unique([
-        ...(previous?.constraints_active ?? []),
+    // v3.9.4: normalized-exact dedupe. The trim-only `unique` let case/space
+    // variants coexist while deriving the SAME c-/cr- id. The silent
+    // max_active_constraints slice is gone: every merged active constraint is
+    // normative, and prompt budget pressure is reported as protectedOverflow.
+    const active = uniqueNormalized([
+        ...(previous.view?.activeConstraints ?? []),
         ...request.constraints_from_plan,
         ...objective.hard_constraints,
         ...objective.success_criteria,
         ...discovered,
     ]).filter((item) => {
-        if (retiredSet.has(item))
+        const key = normalizeText(item);
+        if (immediateRetired.has(key))
             return false;
-        const retractedRound = lastRetractedRound.get(item);
+        const retractedRound = lastRetractedRound.get(key);
         if (retractedRound !== undefined && request.round - retractedRound < window) {
             return false;
         }
         return true;
-    }).slice(0, getPolicy().evolution.max_active_constraints);
+    });
     return { active, retired };
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -266,8 +294,8 @@ criterionFacts = []) {
     if (!objective || objective.success_criteria.length === 0)
         return [];
     const entries = loopEntries(loopId, context).filter((entry) => entryRound(entry) >= 1 && entryRound(entry) < currentRound);
-    // The current round's report lives in last_round_result (the vault only
-    // gains it on commit); treat it as the report for round currentRound - 1.
+    // The previous round's report, resolved from the committed view (or the
+    // library fallback), is treated as the report for round currentRound - 1.
     const lastEv = lastRoundResult?.execution_report;
     const lastMet = claimedMetCriteria(lastEv);
     const lastRemaining = claimedRemainingCriteria(lastEv);
@@ -280,7 +308,16 @@ criterionFacts = []) {
     // sub-goal links carried on the same item, disappeared while the sub-goal
     // side of the very same fact survived. One derivation, one window.
     const factsByCriterion = new Map(criterionFacts.map((fact) => [fact.criterion_id, fact]));
-    return objective.success_criteria.map((text) => {
+    // v3.9.4: one row per derived id. The objective is authored text; a case or
+    // whitespace variant derives the same cr-* and must not produce a second
+    // row (nor a second contract reference space).
+    const seenIds = new Set();
+    const statuses = [];
+    for (const text of objective.success_criteria) {
+        const id = deriveCriterionId(text);
+        if (seenIds.has(id))
+            continue;
+        seenIds.add(id);
         let metAtRound = null;
         for (const entry of entries) {
             const rnd = entryRound(entry);
@@ -300,18 +337,19 @@ criterionFacts = []) {
                 lastEntryRemaining.some((remaining) => criteriaMatch(remaining, text))
                 ? "remaining"
                 : "unknown";
-        const fact = factsByCriterion.get(deriveCriterionId(text));
+        const fact = factsByCriterion.get(id);
         const status = fact?.status ?? claimedStatus;
-        return {
-            id: deriveCriterionId(text),
+        statuses.push({
+            id,
             text,
             status,
             ...(metAtRound !== null ? { met_at_round: metAtRound } : {}),
             // v3.8.1: explicit refs only — empty when no contract item links this
             // criterion to a sub-goal.
             related_subgoal_ids: fact?.related_subgoal_ids ?? [],
-        };
-    });
+        });
+    }
+    return statuses;
 }
 /** v3.8: Rank item statuses so the strongest machine fact wins when several
  *  items reference the same criterion. */
@@ -494,13 +532,16 @@ export { deriveCriterionId, isCriterionId } from "./token-utils.js";
 // ═══════════════════════════════════════════════════════════════════════════
 /** Determine the source of a constraint by matching against known sources. */
 function constraintSource(text, objective, constraintsFromPlan) {
-    const norm = text.toLowerCase().trim();
-    if (objective.hard_constraints.some((c) => c.toLowerCase().trim() === norm))
+    const norm = normalizeText(text);
+    // v3.9.4: criteria identity wins. A text that is both a criterion and a
+    // hard/plan constraint keeps its cr-* id everywhere; the prompt partition
+    // renders it once, in the criteria section.
+    if (objective.success_criteria.some((c) => normalizeText(c) === norm))
+        return "criteria";
+    if (objective.hard_constraints.some((c) => normalizeText(c) === norm))
         return "hard";
-    if (constraintsFromPlan.some((c) => c.toLowerCase().trim() === norm))
+    if (constraintsFromPlan.some((c) => normalizeText(c) === norm))
         return "plan";
-    if (objective.success_criteria.some((c) => c.toLowerCase().trim() === norm))
-        return "criteria";
     return "discovered";
 }
 /** True when a reported violation text matches a constraint text.
@@ -579,40 +620,57 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
     }
     return { active, metadata };
 }
-function levelDecision(request, context) {
-    const previous = getPreviousRound(request.loop_id, request.round - 1, context);
-    const last = request.last_round_result;
-    const hasNewInformation = Boolean(request.new_since_last_round.trim() ||
-        last?.discovered_constraints?.length ||
-        last?.objective_refinement?.trim() ||
-        last?.emerged_subtasks?.length ||
-        last?.retracted_constraints?.length ||
-        last?.revised_success_criteria?.length ||
-        last?.wrong_assumptions?.length);
-    // v2.14: a backtrack committed for this round means the loop is
-    // re-walking restored state — the recovery boundary forces L2
-    // rehydration (the decidePromptLevel recovery_boundary branch existed
-    // but no caller ever set it).
-    const recoveryBoundary = loopEntries(request.loop_id, context)
-        .some((entry) => entryLineage(entry).committed_action === "backtrack" &&
-        entryRound(entry) === request.round);
+/** Resolve the ONE previous-round fact bundle for a compile.
+ *
+ *  The committed view wins whenever a round is committed. `last_round_result`
+ *  is only the caller's in-flight projection for engine/library callers with
+ *  no committed round in the context. In-flight attempt findings are
+ *  authoritative even when empty: a retry must never inherit the previous
+ *  committed round's flags. */
+function resolvePreviousRoundFacts(request, context, windowRounds) {
+    const rounds = windowRounds ??
+        derivationRounds(loopEntries(request.loop_id, context), request.round);
+    const view = rounds.find((round) => round.round === request.round - 1) ?? null;
+    const recoveryBoundary = pendingBacktrackRecord(loopEntries(request.loop_id, context), request.round) !== null;
+    const inFlight = (request.attempt ?? 1) > 1 || recoveryBoundary;
+    return {
+        view,
+        result: view
+            ? roundResultFromCommittedRound(view)
+            : request.last_round_result,
+        verificationFlags: inFlight
+            ? (request.verification_flags ?? [])
+            : (view?.verificationFlags ?? request.verification_flags ?? []),
+        freshness: view ? derivePromptFreshness(view) : UNKNOWN_PROMPT_FRESHNESS,
+        recoveryBoundary,
+    };
+}
+function levelDecision(request, prior, previous) {
     return decidePromptLevel({
         round: request.round,
         attempt: request.attempt,
         forceLevel: request.force_level,
         hasPlanSource: Boolean(request.plan_source),
-        recoveryBoundary,
-        checkpointBoundary: last?.compression_checkpoint === true,
-        goalChanged: previous !== null && previous.goal_id !== deriveGoalId(request.loop_id, request.task, request.goal_id),
-        previousStateMissing: request.round > 1 && previous === null,
-        previousFailedWithoutNewInformation: last?.success === false && !hasNewInformation,
-        verificationContradicted: (request.verification_flags ?? [])
+        recoveryBoundary: previous.recoveryBoundary,
+        checkpointBoundary: previous.result?.compression_checkpoint === true,
+        // An empty goal_id is unobservable, not a goal change: never fabricate L2.
+        goalChanged: prior !== null && prior.goal_id !== "" &&
+            prior.goal_id !== deriveGoalId(request.loop_id, request.task, request.goal_id),
+        previousStateMissing: request.round > 1 && prior === null,
+        previousRoundFailed: previous.view
+            ? previous.view.success === false
+            : previous.result?.success === false,
+        previousRoundObservableNewInformation: previous.view
+            ? previous.freshness.observableNewInformation
+            : null,
+        verificationContradicted: previous.verificationFlags
             .some((flag) => flag.severity === "error"),
         consecutiveRejections: request.consecutive_rejections,
     });
 }
 export function decideLevel(request, context) {
-    return levelDecision(request, context).level;
+    const prior = getPreviousRound(request.loop_id, request.round - 1, context);
+    return levelDecision(request, prior, resolvePreviousRoundFacts(request, context)).level;
 }
 /** The prompt's evaluation block. All content (examples, contract/sub-goal
  *  guidance, flag-specific hints) comes from the one FIELD_GUIDES table in
@@ -630,47 +688,85 @@ export function buildSelfEvalBlock(ctx) {
  *  rollback decision's own fields — no new persistence, no rejected
  *  payloads. */
 function committedBacktrackBrief(loopId, round, context) {
-    const entry = loopEntries(loopId, context).find((e) => entryLineage(e).committed_action === "backtrack" && entryRound(e) === round);
-    if (!entry)
-        return undefined;
-    // v3.8.1: one decoder for the committed rollback record and one renderer for
-    // the brief. The facts ride on the merged lineage entry (engine.ts stamps
-    // them from the committed decision) and the same `decodeBacktrackRecord`
-    // reads the durable :feedback envelope, so both carriers decode to one shape
-    // — and this brief and the rollback prompt no longer render the same
-    // rollback with two hand-written line builders.
-    const record = decodeBacktrackRecord(entryLineage(entry));
+    // The SAME pending-backtrack lookup the recovery boundary uses: a deep
+    // restore commits at the failed round while its redo targets
+    // `backtrackTarget + 1`, so an exact-round match loses both the boundary
+    // and this brief.
+    const view = pendingBacktrackRecord(loopEntries(loopId, context), round);
+    const record = view?.backtrack;
     if (!record)
         return undefined;
-    return recoveryBriefLines({
+    const lines = recoveryBriefLines({
         target: record.target,
         triggerRule: record.triggerRule,
+        // The committed decision's own sentence — the machine's reason for the
+        // rollback, preserved as a fact (the old prose header's "Why" content).
+        ...(typeof view?.result?.enforcementReason === "string" &&
+            view.result.enforcementReason.trim()
+            ? { failureReason: view.result.enforcementReason }
+            : {}),
         failedRounds: record.failedRounds,
         approaches: record.approaches,
         wrongAssumptions: record.wrongAssumptions,
+        // The redo round's stable identity is a fact the old prepended prose
+        // carried; keep it inside the artifact now.
+        recoveryRoundId: `loop:${loopId}:round:${record.target + 1}`,
     });
+    // v3.9.4: the restore point's machine facts belong in the prompt, not only
+    // in the prose backtrack header. Deterministic order and a visible overflow
+    // count keep the fact complete without making the section unbounded.
+    if (record.targetGitHead) {
+        lines.push(`- **Restore HEAD**: \`${record.targetGitHead}\``);
+    }
+    if (record.skippedFiles.length > 0) {
+        const files = [...record.skippedFiles].sort();
+        const shown = files.slice(0, 15);
+        lines.push("- **Files changed in failed rounds**:");
+        for (const file of shown)
+            lines.push(`  - \`${file}\``);
+        if (files.length > shown.length) {
+            lines.push(`  - … and ${files.length - shown.length} more files`);
+        }
+    }
+    // The machine requirement the recovery checkpoint enforces. A fact, not a
+    // recipe: LoopForge never says HOW to restore the workspace.
+    if (record.targetGitHead || record.skippedFiles.length > 0) {
+        lines.push(`- **Restore requirement**: the next submission's workspace is checked ` +
+            `against round ${record.target}` +
+            (record.targetGitHead ? ` (HEAD \`${record.targetGitHead}\`)` : "") +
+            "; a leftover change from the failed rounds rejects the recovery checkpoint.");
+    }
+    return lines;
 }
 export function compileLoop(request, context) {
-    const decision = levelDecision(request, context);
-    const previous = getPreviousRound(request.loop_id, request.round - 1, context);
-    const objective = evolveObjective(request, context);
-    const constraints = evolveConstraints(request, objective, previous, context);
-    const constraintLifecycle = manageConstraintLifecycle(constraints.active, objective, request.constraints_from_plan, context, request.round, request.last_round_result?.constraint_violations ?? []);
-    const rolling = buildRollingSummary(request.loop_id, request.round, context, 0);
-    // v3.8: ONE committed-round derivation feeds every projection below
-    // (sub-goals, the active contract, its item statuses, criteria).
+    // ONE history window and ONE previous-round fact bundle for the whole
+    // compile. Every consumer below reads these values; none re-reads the
+    // caller's mutable last_round_result.
     const windowRounds = derivationRounds(loopEntries(request.loop_id, context), request.round);
+    const prior = getPreviousRound(request.loop_id, request.round - 1, context);
+    const previous = resolvePreviousRoundFacts(request, context, windowRounds);
+    const decision = levelDecision(request, prior, previous);
+    const objective = evolveObjective(request, context, previous);
+    const constraints = evolveConstraints(request, objective, previous, windowRounds);
+    const constraintLifecycle = manageConstraintLifecycle(constraints.active, objective, request.constraints_from_plan, context, request.round,
+    // "Violated this round" means the CURRENT compile round's report. A
+    // committed previous round's violations are found by the committed
+    // history scan at their real round, not relabelled as this round.
+    previous.view ? [] : (request.last_round_result?.constraint_violations ?? []));
+    const rolling = buildRollingSummary(request.loop_id, request.round, context, 0);
     // v3.8: sub-goal lifecycle lives in subgoal-state.ts and consumes the
-    // shared committed-round view — one history interpretation.
+    // shared committed-round view — one history interpretation. The previous
+    // round's report is idempotently replayed; a committed round is already in
+    // the window, while the library fallback has no view.
     const subGoals = deriveSubGoals({
         loopId: request.loop_id,
         currentRound: request.round,
         rounds: windowRounds,
-        currentReport: request.last_round_result
+        currentReport: previous.result
             ? {
-                round: request.last_round_result.round || (request.round - 1),
-                emergedSubtasks: request.last_round_result.emerged_subtasks ?? [],
-                subgoalUpdates: request.last_round_result.subgoal_updates ?? [],
+                round: previous.result.round || (request.round - 1),
+                emergedSubtasks: previous.result.emerged_subtasks ?? [],
+                subgoalUpdates: previous.result.subgoal_updates ?? [],
             }
             : null,
     });
@@ -692,8 +788,18 @@ export function compileLoop(request, context) {
     // `roundFacts.verifiedSubGoals` is not read here — it reaches the state file
     // and the projection through the bundle itself.
     const { activeContract } = roundFacts;
+    // v3.9.4: the criterion reference space is the ACTIVE criterion set, not
+    // every text the objective ever carried. A retracted criterion must not be
+    // claimable or contract-referenceable while the prompt does not render it.
+    const activeConstraintKeys = new Set(constraintLifecycle.active.map((text) => normalizeText(text)));
+    const activeCriteria = uniqueNormalized(objective.success_criteria)
+        .filter((text) => activeConstraintKeys.has(normalizeText(text)));
+    const criterionObjective = {
+        ...objective,
+        success_criteria: activeCriteria,
+    };
     // v3.2: Goal → criteria → evidence vertical view (derived, zero persistence).
-    const criterionStatuses = deriveCriterionStatuses(request.loop_id, context, objective, request.round, request.last_round_result, roundFacts.criterionFacts);
+    const criterionStatuses = deriveCriterionStatuses(request.loop_id, context, criterionObjective, request.round, previous.result, roundFacts.criterionFacts);
     // v3.8.1: the ONE recurring-fact derivation, over the shared window. The
     // prompt renders its recent tail; the state file renders the recurring set.
     const recurringFlags = deriveRecurringFlags(windowRounds);
@@ -703,7 +809,7 @@ export function compileLoop(request, context) {
     // gone with the rest of the fuzzy matching, and so are the task-alignment
     // and loop-health warnings: both were Jaccard scores over task/objective
     // text, never machine facts.
-    const repeatedDeclarations = duplicateEmergedDeclarations(request.last_round_result?.emerged_subtasks ?? []);
+    const repeatedDeclarations = duplicateEmergedDeclarations(previous.result?.emerged_subtasks ?? []);
     const warnings = unique([
         repeatedDeclarations.length > 0
             ? `duplicate_declaration: ${repeatedDeclarations.length} sub-goal ` +
@@ -718,14 +824,12 @@ export function compileLoop(request, context) {
     // `constraint_violations`, i.e. a DIFFERENT source from the score it was
     // displayed next to. "Trend" was therefore not the score's history at all.
     // Neither fed a decision.
-    const completedEntries = loopEntries(request.loop_id, context)
-        .filter((e) => entryRound(e) >= 1 && entryRound(e) < request.round);
-    const committedRounds = derivationRounds(completedEntries, request.round);
     // v3.3/v3.8.1: machine git-motion (display-only, derived). The per-round
     // "round stats" table is deleted: its only renderer was the L2 prompt
     // section removed above, so it was computed, put into the canonical state
-    // (and therefore into stateHash) and read by nothing.
-    const machineStatus = deriveMachineStatus(committedRounds, request.round);
+    // (and therefore into stateHash) and read by nothing. `windowRounds` is the
+    // ONE window computed at the top of this function.
+    const machineStatus = deriveMachineStatus(windowRounds, request.round);
     const response = makeLoopCompileResponse({
         status: AgentStatus.OK,
         recompile_level: decision.level,
@@ -760,6 +864,10 @@ export function compileLoop(request, context) {
         // truth, its verification view and the machine-verified sub-goal facts as
         // ONE derivation. The static capability rides on the state itself.
         roundFacts,
+        // 3.9.3: the same previous-round bundle the level decision used. This is
+        // what keeps changes/discoveries/blockers/remaining/progress identical on
+        // live, resume, and unpause compiles.
+        previousRound: previous,
     });
     // The recovery brief is a current-round fact, computed once and shared by
     // the state file and the evaluation block. It never becomes prompt control
@@ -808,14 +916,19 @@ export function compileLoop(request, context) {
             commands: contractCommands,
             contractVerificationAvailable: configuredCapability.contractVerificationAvailable,
             subGoals,
-            verificationFlags: request.verification_flags ?? [],
+            verificationFlags: previous.verificationFlags,
             recovery: recoveryBrief !== undefined,
             gateEnabled: policy.gate.enabled === true,
             criteria: criterionStatuses,
+            currentRequirement: state.currentTask,
         }),
         fullStateMarkdown: l2Pointer ? undefined : markdown,
+        // v3.9.4: the SAME committed-backtrack facts the state file renders. The
+        // recovery section is part of the artifact, so the delivered prompt is
+        // exactly `artifact.renderedPrompt` (no post-compile prepend).
+        recoveryBrief,
         // v2.9: Model's information needs from the previous round's SelfEvaluation
-        promptRequests: request.last_round_result?.prompt_requests,
+        promptRequests: previous.result?.prompt_requests,
     });
     response.prompt = artifact.renderedPrompt;
     response.prompt_artifact = artifact;