loopforge 3.2.1 → 3.6.0

package/dist/loop-compiler.js

@@ -7,6 +7,8 @@ import { createHash } from "node:crypto";
 import { getPolicy } from "./policy.js";
 import { AgentStatus, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, makeSubGoal, makeTaskAlignment, } from "./protocol.js";
 import { createCanonicalLoopState, renderCanonicalStateMarkdown, } from "./canonical-state.js";
+import { decodeCommittedRound, decodeMergedRound, machineGitMotionSeries, mergedRoundsFromEntries, } from "./committed-round.js";
+import { contractRoundEvaluations, deriveActiveRoundContract, } from "./round-contract.js";
 import { assemblePromptArtifact } from "./prompt-assembler.js";
 import { decidePromptLevel, } from "./prompt-policy.js";
 import { deriveItemId, jaccardSimilarity, unique, entryRound } from "./token-utils.js";
@@ -26,6 +28,35 @@ function loopEntries(loopId, context) {
         .filter((entry) => entry.loop_id === loopId || lineage(entry).loop_id === loopId)
         .sort((a, b) => entryRound(a) - entryRound(b));
 }
+/** v3.3.1: The canonical entry for a round — its compile-time lineage entry
+ *  (task_type "loop_lineage"; engine hydration merges the committed
+ *  decision into it, so one round = one merged lineage entry in the
+ *  compiler's view). Event/journal entries (delegation journals, gate
+ *  records) share lineage.round with the round but carry none of its
+ *  compile-time fields; round-level consumers that matched on the round
+ *  number alone could hit them first (they sort after the lineage entry of
+ *  the same round), producing an empty goal_id / task / constraints_active
+ *  and forcing spurious L2 recovery. A direct :feedback entry is accepted
+ *  when the caller supplies a raw committed view instead of hydration. */
+function roundCanonicalEntry(entries, round) {
+    const candidates = entries.filter((entry) => entryRound(entry) === round);
+    return (candidates.find((entry) => entry.task_type === "loop_lineage") ??
+        candidates.find((entry) => String(entry.task_id ?? "").endsWith(":feedback")) ??
+        // Untyped compiler inputs are treated as round views, not events. Known event
+        // types (delegation journals, gate records) are excluded explicitly so
+        // they can never shadow a round again.
+        candidates.find((entry) => {
+            const type = String(entry.task_type ?? "");
+            return type === "" || (!type.startsWith("delegation") && !type.endsWith("journal"));
+        }) ??
+        null);
+}
+/** Return the canonical read model when an entry is a committed round.
+ * Uncommitted compiler lineage has no durable decision yet and deliberately
+ * remains on the local compile path; it cannot be treated as history. */
+function committedView(entry) {
+    return decodeMergedRound(entry) ?? decodeCommittedRound(entry);
+}
 export function computeGoalTextHash(text) {
     const normalized = text.trim().replace(/\s+/g, " ").toLowerCase();
     return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
@@ -38,12 +69,10 @@ export function deriveGoalId(loopId, task, explicit = "") {
 }
 /** v3.2: Read the previous round's persisted L1 presentation snapshot — the
  *  diff baseline for L1 collapse. Returns null when the previous round's
- *  lineage entry exists but lacks all three presented_* fields (old-format
- *  entries, L0/L2 compiles) — callers then render in full, which keeps
- *  existing fixtures and pre-v3.2 loops on the full-render path. */
+ *  lineage entry lacks the three presented_* fields (as on L0/L2 compiles),
+ *  so callers render the full L1 state. */
 export function readPresentedBaseline(loopId, round, context) {
-    const entry = [...loopEntries(loopId, context)].reverse()
-        .find((candidate) => entryRound(candidate) === round - 1);
+    const entry = roundCanonicalEntry(loopEntries(loopId, context), round - 1);
     if (!entry)
         return null;
     const data = lineage(entry);
@@ -65,8 +94,7 @@ export function readPresentedBaseline(loopId, round, context) {
     };
 }
 export function getPreviousRound(loopId, round, context) {
-    const entry = [...loopEntries(loopId, context)].reverse()
-        .find((candidate) => entryRound(candidate) === round);
+    const entry = roundCanonicalEntry(loopEntries(loopId, context), round);
     if (!entry)
         return null;
     const data = lineage(entry);
@@ -196,6 +224,9 @@ function evolveConstraints(request, objective, previous, context) {
 /** Extract execution_evidence from a vault entry, handling both direct-field
  *  and lineage-nested shapes. Returns null when absent. */
 function entryExecutionEvidence(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.executionEvidence;
     const direct = entry.execution_evidence;
     if (direct && typeof direct === "object" && !Array.isArray(direct)) {
         return direct;
@@ -209,6 +240,10 @@ function entryExecutionEvidence(entry) {
 }
 /** Read success_criteria_met from an entry's execution_evidence. */
 function entryCriteriaMet(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.executionEvidence?.success_criteria_met
+            ?.filter((value) => typeof value === "string") ?? [];
     const ev = entryExecutionEvidence(entry);
     if (!ev)
         return [];
@@ -217,6 +252,10 @@ function entryCriteriaMet(entry) {
 }
 /** Read success_criteria_remaining from an entry's execution_evidence. */
 function entryCriteriaRemaining(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.executionEvidence?.success_criteria_remaining
+            ?.filter((value) => typeof value === "string") ?? [];
     const ev = entryExecutionEvidence(entry);
     if (!ev)
         return [];
@@ -234,17 +273,20 @@ export function deriveLessons(loopId, context, currentRound) {
     const warns = new Map();
     for (const entry of entries) {
         const rnd = entryRound(entry);
-        const viols = Array.isArray(entry.constraint_violations)
-            ? entry.constraint_violations.filter((v) => typeof v === "string")
-            : [];
+        const view = committedView(entry);
+        const viols = view
+            ? view.constraintViolations ?? []
+            : Array.isArray(entry.constraint_violations)
+                ? entry.constraint_violations.filter((v) => typeof v === "string")
+                : [];
         for (const text of viols) {
             const list = violations.get(text) ?? [];
             list.push(rnd);
             violations.set(text, list);
         }
-        const flags = Array.isArray(entry.verification_flags)
-            ? entry.verification_flags
-            : [];
+        const flags = view
+            ? view.verificationFlags
+            : Array.isArray(entry.verification_flags) ? entry.verification_flags : [];
         for (const flag of flags) {
             const target = flag.severity === "error"
                 ? errors
@@ -274,6 +316,59 @@ export function deriveLessons(loopId, context, currentRound) {
     }
     return lessons.sort((a, b) => b.count - a.count);
 }
+/** v3.3: Derive display-only round statistics over the last `window`
+ *  committed rounds — files changed, rejected attempts (snapshot.attempt
+ *  minus one: the successful commit's attempt counts the redo), and the
+ *  self-reported progress delta vs the previous round. One row per round,
+ *  preferring the :feedback entry when both lineage and feedback entries
+ *  exist. Zero persistence — re-derived from committed entries. */
+function deriveRoundStats(rounds, window = 5) {
+    const stats = [];
+    let prevProgress = null;
+    for (const round of rounds.slice(-window)) {
+        const ev = round.executionEvidence;
+        const files = ev?.files_changed;
+        const rawProgress = ev?.progress_estimate;
+        const progress = typeof rawProgress === "number" ? rawProgress : null;
+        stats.push({
+            round: round.round,
+            filesChangedCount: Array.isArray(files) ? files.length : null,
+            rejectedAttempts: round.attempt >= 1 ? round.attempt - 1 : null,
+            progressDelta: progress !== null && prevProgress !== null
+                ? Number((progress - prevProgress).toFixed(3))
+                : null,
+        });
+        if (progress !== null)
+            prevProgress = progress;
+    }
+    return stats;
+}
+/** v3.3: Machine git-motion cross-check over the last 3 committed rounds
+ *  (the R4 window). Undefined when no committed rounds carry git snapshots
+ *  — the dashboard then shows no machine row. Display-only companion to the
+ *  R4/R5 exculpatory signal. */
+function deriveMachineStatus(rounds, currentRound) {
+    const series = machineGitMotionSeries(rounds, currentRound, 3);
+    if (series === null)
+        return undefined;
+    const motionRounds = series.filter(Boolean).length;
+    return { windowRounds: 3, gitMotion: motionRounds > 0, motionRounds };
+}
+/** v3.4: ACTIVE Round Contract for the compile round — derived from the
+ *  committed evals of earlier rounds only, never from request data. Reads
+ *  the hydrated merged lineage entries (one per round; a committed decision
+ *  is merged onto the round's lineage entry with `committed_action` set),
+ *  skipping rounds whose committed action was "backtrack" (a roll-back
+ *  directive, not an executed round). Because it runs identically on every
+ *  compile path — including rejection retries and resume / unpause /
+ *  backtrack compiles that carry no last_round_result — a contract round's
+ *  re-compiles keep showing its contract as the Current Task. Null when no
+ *  active contract: the Current Task falls back to the original task text. */
+function deriveActiveContract(loopId, context, currentRound) {
+    const entries = loopEntries(loopId, context);
+    const canonical = Array.from({ length: Math.max(0, currentRound - 1) }, (_, index) => roundCanonicalEntry(entries, index + 1)).filter((entry) => entry !== null);
+    return deriveActiveRoundContract(contractRoundEvaluations(mergedRoundsFromEntries(canonical, currentRound)));
+}
 /** v3.2: Derive per-criterion status — the "goal → criteria → evidence"
  *  vertical view. Each objective criterion gets: met/remaining/unknown
  *  (from per-round success_criteria_met/remaining reports, ID-first
@@ -323,8 +418,10 @@ export function deriveCriterionStatuses(loopId, context, objective, currentRound
 }
 /** v2.11: Match two criterion references for deduplication.
  *  If either is a criterion ID (cr-XXXXXXXX), uses exact ID comparison.
- *  Otherwise falls back to Jaccard similarity. */
-function criteriaMatch(a, b) {
+ *  Otherwise falls back to Jaccard similarity.
+ *  v3.3: exported for the verification gate's windowed criteria-completion
+ *  scan (R4/R5 exculpatory cross-check). */
+export function criteriaMatch(a, b) {
     const aIsId = isCriterionId(a);
     const bIsId = isCriterionId(b);
     // Both are IDs — exact string comparison
@@ -341,7 +438,7 @@ function criteriaMatch(a, b) {
 /** Detect newly met criteria by comparing the current entry's
  *  success_criteria_met against the previous entry's.
  *  v2.11: ID-first matching (cr-XXXXXXXX) with Jaccard similarity
- *  fallback for backward compatibility.
+ *  fallback for natural-language references.
  *  Returns empty array when there is no previous entry — the first
  *  entry's criteria are the baseline, not a "new" event. */
 function detectNewCriteria(current, previous) {
@@ -359,12 +456,18 @@ function detectNewCriteria(current, previous) {
 }
 /** Read constraints_active from an entry's lineage. */
 function entryActiveConstraints(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.activeConstraints ?? [];
     const lin = lineage(entry);
     const arr = lin.constraints_active;
     return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
 }
 /** Read retracted_constraints from an entry. */
 function entryRetractedConstraints(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.retractedConstraints ?? [];
     const direct = entry.retracted_constraints;
     if (Array.isArray(direct))
         return direct.filter((v) => typeof v === "string");
@@ -385,9 +488,10 @@ function entryProgressEstimate(entry) {
 /** Build a single MilestoneSummary from a range of completed round entries. */
 function buildMilestoneFromEntries(phaseEntries, startRound, endRound, label, kind) {
     const last = phaseEntries.at(-1);
-    const outcomeRaw = last
-        ? (typeof last.output_summary === "string" ? last.output_summary : "")
-        : "";
+    const lastView = last ? committedView(last) : null;
+    const outcomeRaw = lastView
+        ? (lastView.outputSummary ?? "")
+        : last && typeof last.output_summary === "string" ? last.output_summary : "";
     const outcomeMax = getPolicy().checkpoint.outcome_max_chars;
     const outcome = outcomeRaw.length > outcomeMax
         ? outcomeRaw.slice(0, outcomeMax) + "…"
@@ -468,24 +572,29 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
     const outcomes = [];
     const issues = [];
     for (const entry of windowEntries) {
+        const view = committedView(entry);
         const data = lineage(entry);
         const round = entryRound(entry);
-        const success = entry.success ?? data.success;
-        const summary = typeof entry.output_summary === "string"
-            ? entry.output_summary
-            : typeof data.output_summary === "string" ? data.output_summary : "";
+        const success = view ? view.success : entry.success ?? data.success;
+        const summary = view
+            ? view.outputSummary ?? ""
+            : typeof entry.output_summary === "string"
+                ? entry.output_summary
+                : typeof data.output_summary === "string" ? data.output_summary : "";
         // v2.12: Declared outcome wins the label; the default wording stays
         // "accepted" for zero regression on existing loop output.
-        const declared = entry.outcome;
+        const declared = view ? view.outcome : entry.outcome;
         const outcomeLabel = declared === "success" || declared === "partial" ||
             declared === "failed" || declared === "blocked"
             ? declared
             : success === false ? "failed" : "accepted";
         if (summary)
             outcomes.push(`[R${round}] ${outcomeLabel}: ${summary}`);
-        const violations = Array.isArray(entry.constraint_violations)
-            ? entry.constraint_violations
-            : Array.isArray(data.constraint_violations) ? data.constraint_violations : [];
+        const violations = view
+            ? view.constraintViolations ?? []
+            : Array.isArray(entry.constraint_violations)
+                ? entry.constraint_violations
+                : Array.isArray(data.constraint_violations) ? data.constraint_violations : [];
         issues.push(...violations.filter((item) => typeof item === "string"));
     }
     // ── Phase 2: Milestone Accumulation ──
@@ -521,10 +630,17 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
             lastMilestoneRound = rnd;
         }
     }
-    // Signal 3: Safety net — auto milestone when gap exceeds milestone_interval
+    // Signal 3: Safety net — auto milestone when gap exceeds milestone_interval.
+    // v3.3.1: the policy contract (milestone_interval: "only fires when no
+    // agent_declared or criteria_milestone has been created for this many
+    // rounds") includes loops that NEVER created a milestone — but the guard
+    // `lastMilestoneRound > 0` made the gap start from the (nonexistent) first
+    // milestone, so a checkpoint-less loop could run forever with an empty
+    // Phase History and no memory skeleton. With lastMilestoneRound == 0 the
+    // gap is measured from round 1 and the safety net fires from the very
+    // first interval.
     const gapSinceLast = (currentRound - 1) - lastMilestoneRound;
-    if (lastMilestoneRound > 0 &&
-        gapSinceLast >= policy.milestone_interval &&
+    if (gapSinceLast >= policy.milestone_interval &&
         completedEntries.length > 0) {
         const startRound = lastMilestoneRound + 1;
         const endRound = currentRound - 1;
@@ -540,23 +656,6 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
     // L2 (full rehydration) keeps every milestone — the recovery view is the
     // loop's memory skeleton and must not be truncated.
     const cappedMilestones = sampleMilestones(milestones, policy, level);
-    // ── Phase 3: Loop Synthesis (formulaic) ──
-    let loopSynthesis = "";
-    if (policy.enable_loop_synthesis && currentRound > 1) {
-        const totalRounds = currentRound - 1;
-        const phaseCount = cappedMilestones.length;
-        const lastProgress = completedEntries.length > 0
-            ? entryProgressEstimate(completedEntries[completedEntries.length - 1])
-            : 0;
-        const activeCount = completedEntries.length > 0
-            ? entryActiveConstraints(completedEntries[completedEntries.length - 1]).length
-            : 0;
-        const totalResolved = cappedMilestones.reduce((sum, m) => sum + m.resolved_constraints.length, 0);
-        loopSynthesis =
-            `Loop spans ${totalRounds} rounds across ${phaseCount} phases. ` +
-                `Overall progress: ${(lastProgress * 100).toFixed(0)}%. ` +
-                `${activeCount} active constraints, ${totalResolved} resolved across all phases.`;
-    }
     if (windowEntries.length === 0 && cappedMilestones.length === 0)
         return null;
     return makeRollingSummary({
@@ -566,7 +665,6 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
         generated_at_round: currentRound,
         failed_patterns: [],
         milestones: cappedMilestones,
-        loop_synthesis: loopSynthesis || undefined,
     });
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -599,6 +697,9 @@ export function isCriterionId(ref) {
 }
 /** Read emerged_subtasks from a vault entry (handles direct + lineage nesting). */
 function entryEmergedSubtasks(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.emergedSubtasks ?? [];
     const direct = entry.emerged_subtasks;
     if (Array.isArray(direct))
         return direct.filter((v) => typeof v === "string");
@@ -610,6 +711,9 @@ function entryEmergedSubtasks(entry) {
 }
 /** Read completed_subtasks from an entry. */
 function entryCompletedSubtasks(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.completedSubtasks ?? [];
     const direct = entry.completed_subtasks;
     if (Array.isArray(direct))
         return direct.filter((v) => typeof v === "string");
@@ -617,6 +721,9 @@ function entryCompletedSubtasks(entry) {
 }
 /** Read blocked_subtasks from an entry. */
 function entryBlockedSubtasks(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.blockedSubtasks ?? [];
     const direct = entry.blocked_subtasks;
     if (Array.isArray(direct))
         return direct.filter((v) => typeof v === "string");
@@ -624,6 +731,9 @@ function entryBlockedSubtasks(entry) {
 }
 /** Read canceled_subtasks from an entry. */
 function entryCanceledSubtasks(entry) {
+    const view = committedView(entry);
+    if (view)
+        return view.canceledSubtasks ?? [];
     const direct = entry.canceled_subtasks;
     if (Array.isArray(direct))
         return direct.filter((v) => typeof v === "string");
@@ -816,9 +926,12 @@ function findDiscoveredRound(text, vaultEntries) {
         const rnd = entryRound(entry);
         if (rnd < 1)
             continue;
-        const discovered = Array.isArray(entry.discovered_constraints)
-            ? entry.discovered_constraints.filter((v) => typeof v === "string")
-            : [];
+        const view = committedView(entry);
+        const discovered = view
+            ? view.discoveredConstraints ?? []
+            : Array.isArray(entry.discovered_constraints)
+                ? entry.discovered_constraints.filter((v) => typeof v === "string")
+                : [];
         for (const d of discovered) {
             // Phase 1: exact ID match (v2.11)
             if (d === targetId || deriveConstraintId(d) === targetId) {
@@ -826,7 +939,7 @@ function findDiscoveredRound(text, vaultEntries) {
                     earliest = rnd;
                 break;
             }
-            // Phase 2: Jaccard fallback (backward compatibility)
+            // Phase 2: Jaccard fallback for natural-language references.
             if (jaccardSimilarity(text, d) >= getPolicy().evolution.constraint_match_threshold) {
                 if (earliest === 0 || rnd < earliest)
                     earliest = rnd;
@@ -856,9 +969,12 @@ function findLastViolatedRound(text, vaultEntries) {
         const rnd = entryRound(entry);
         if (rnd < 1)
             continue;
-        const violations = Array.isArray(entry.constraint_violations)
-            ? entry.constraint_violations.filter((v) => typeof v === "string")
-            : [];
+        const view = committedView(entry);
+        const violations = view
+            ? view.constraintViolations ?? []
+            : Array.isArray(entry.constraint_violations)
+                ? entry.constraint_violations.filter((v) => typeof v === "string")
+                : [];
         for (const v of violations) {
             if (matchesConstraintText(text, v)) {
                 if (rnd > latest)
@@ -893,8 +1009,15 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
         const violatedThisRound = lastRoundViolations.some((v) => matchesConstraintText(text, v));
         // Structural constraints never decay
         if (source === "hard" || source === "plan" || source === "criteria") {
+            // v3.3.1: one text, one identity — a success-criterion text that also
+            // lives in the merged active set belongs to the cr-XXXXXXXX namespace
+            // (its own Success Criteria section and the verification gate's
+            // criteriaMatch are ID-first on cr-). Rendering it under c-XXXXXXXX in
+            // the active list meant the same text carried two IDs in one prompt,
+            // and an agent echoing the active-list ID into success_criteria_met
+            // could never match.
             metadata.push(makeConstraintMeta({
-                id: deriveConstraintId(text),
+                id: source === "criteria" ? deriveCriterionId(text) : deriveConstraintId(text),
                 text,
                 discovered_at_round: objective.created_at_round || 1,
                 last_violated_at_round: violatedThisRound
@@ -1011,11 +1134,24 @@ export function buildSelfEvalBlock(round, prevDriftFlags,
 /** v2.12: L0 is the minimal retry template — the v2.12 declarative fields
  *  (outcome/blocker/retroactiveClaims) are L1/L2 additions so the retry
  *  prompt stays within its tight budget. */
-level) {
+level, 
+/** v3.3/v3.4: Whether this round's Current Task IS the ACTIVE Round
+ *  Contract (derived from committed rounds — compileLoop passes
+ *  `activeContract != null`). Only then does the template ask the agent
+ *  to restate/propose it — a generic empty contract template would invite
+ *  placeholder submissions that trigger round_underspecified noise. */
+hasContract = false, 
+/** v3.5: L2-only prose suggesting a Round Contract declaration when the
+ *  Current Task is NOT one (contract_nudge_on_l2 policy, computed at the
+ *  compileLoop call site). Mutually exclusive with hasContract. The prose
+ *  must never contain the JSON key name `round_contract` — contract-less
+ *  L2 tests assert its lowercase absence. */
+proposalNudge = false) {
     const hasIntentDrift = prevDriftFlags?.some(f => f.check === "intent_drift") ?? false;
     const hasSubGoalDrift = prevDriftFlags?.some(f => f.check === "subgoal_drift") ?? false;
     const needsClarification = hasIntentDrift || hasSubGoalDrift;
     const declareOutcome = level !== "l0";
+    const restateContract = hasContract && declareOutcome;
     const evalObj = {
         success: false,
         output_summary: `<verified result of round ${round}>`,
@@ -1042,6 +1178,20 @@ level) {
         evalObj.blocker = "<required only when outcome=blocked>";
         evalObj.retroactiveClaims = [];
     }
+    // v3.3/v3.4: Round Contract proposal template (L1/L2, active-contract
+    // rounds only — L0 retry stays lean, and rounds without an active
+    // contract never see the template). When the prompt's Current Task IS the
+    // ACTIVE contract, the agent restates it unchanged as its proposal; when
+    // the active contract's done_when are all satisfied (or the round is
+    // blocked), a NEW contract is declared for the next round instead.
+    if (restateContract) {
+        evalObj.round_contract = {
+            work_item: "<this round's focus, or empty>",
+            done_when: [],
+            verification_plan: [],
+            scope: [],
+        };
+    }
     // v2.8: Inject drift clarification field when previous round had drift flags
     if (needsClarification) {
         const flagTypes = [
@@ -1057,19 +1207,27 @@ level) {
         "### LoopForge Evaluation (Required)",
         "",
         `After completing Round ${round}, replace the placeholder values below`,
-        "with your actual results and submit via `loopforge_next`.",
+        "with your actual results and pass this object as `loopforge_next.evaluation`.",
     ];
     if (needsClarification) {
         lines.push("", "> ⚠️ **Drift Detected:** The verification gate detected that your previous", "> round's declared intent (next_action) did not match your actual output.", "> Please explain the pivot in the `drift_clarification` field below.", "> An honest explanation helps the enforcement gate distinguish intentional", "> course corrections from unacknowledged drift.");
     }
-    lines.push("---loopforge-eval");
+    lines.push("```json");
     lines.push(JSON.stringify(evalObj, null, 2));
-    lines.push("---end-loopforge-eval");
+    lines.push("```");
     lines.push("");
     lines.push("IMPORTANT: Replace every <placeholder> with your actual data.");
     lines.push("Set success=true only when the full goal and ALL hard constraints are verified.");
     lines.push("Use IDs for exact matching: c-XXXXXXXX, cr-XXXXXXXX, sg-XXXXXXXX.");
     lines.push("For subtasks, use sub-goal IDs from the Sub-Goal Dashboard above.");
+    // v3.5: L2 contract-less nudge (prose only — never the JSON key name, so
+    // contract-less rounds keep their template-lean assertions).
+    if (proposalNudge) {
+        lines.push("", "If the remaining work will span several rounds, consider declaring a", "Round Contract for the next round — list its done_when items, the", "verification_plan commands that will back them, and the scope. This", "keeps each round's boundary machine-checkable.");
+    }
+    if (restateContract) {
+        lines.push("Round Contract: restate the Current Task's contract UNCHANGED in", "`round_contract` (work_item/done_when/verification_plan/scope) and run", "its Verify commands; list satisfied done_when items in", "`success_criteria_met`. When the current contract's done_when items are", "all satisfied, or the round is blocked (outcome=blocked + blocker),", "declare the NEXT round's contract instead (or omit `round_contract`", "when the whole task is done — the Current Task reverts to the", "original task).");
+    }
     return lines.join("\n");
 }
 // v2.5: checkpoint() removed — agent_declared milestones from
@@ -1104,15 +1262,22 @@ export function compileLoop(request, context) {
     // No new persistence; reconstructed same as milestones/sub-goals.
     const completedEntries = loopEntries(request.loop_id, context)
         .filter((e) => entryRound(e) >= 1 && entryRound(e) < request.round);
+    const committedRounds = mergedRoundsFromEntries(completedEntries, request.round);
     const trend = [];
-    for (const entry of completedEntries.slice(-10)) {
-        const viols = Array.isArray(entry.constraint_violations)
-            ? entry.constraint_violations.filter((v) => typeof v === "string")
-            : [];
+    for (const round of committedRounds.slice(-10)) {
+        const viols = round.evaluation?.constraint_violations ?? [];
         // Simple proxy: no violations = perfect trust, each violation = -0.1
         const score = Math.max(0, 1.0 - viols.length * 0.1);
         trend.push(Number(score.toFixed(2)));
     }
+    // v3.3: Round stats + machine git-motion status (display-only, derived).
+    const roundStats = deriveRoundStats(committedRounds);
+    const machineStatus = deriveMachineStatus(committedRounds, request.round);
+    // v3.4: ACTIVE Round Contract for this compile — derived from committed
+    // rounds, so rejection retries / resume / unpause / backtrack compiles
+    // (no last_round_result) keep showing the contract as Current Task, and a
+    // satisfied or blocked contract stops being shown.
+    const activeContract = deriveActiveContract(request.loop_id, context, request.round);
     const response = makeLoopCompileResponse({
         status: AgentStatus.OK,
         recompile_level: decision.level,
@@ -1142,7 +1307,12 @@ export function compileLoop(request, context) {
     });
     const policy = getPolicy();
     const statePath = `${policy.state_file.directory}/${request.loop_id}-state.md`;
-    const state = createCanonicalLoopState(request, response, statePath);
+    const state = createCanonicalLoopState(request, response, statePath, {
+        roundStats,
+        machineStatus,
+        // v3.4: derived active contract — the Current Task's source of truth.
+        roundContract: activeContract,
+    });
     const markdown = renderCanonicalStateMarkdown(state);
     // v2.4–v2.5: Adaptive L2 budget — scales with loop complexity
     const adaptiveL2 = policy.prompt.l2_adaptive_enabled
@@ -1166,7 +1336,15 @@ export function compileLoop(request, context) {
             l2: adaptiveL2,
         },
         attempt: request.attempt,
-        selfEvaluationBlock: buildSelfEvalBlock(request.round, request.verification_flags, decision.level),
+        selfEvaluationBlock: buildSelfEvalBlock(request.round, request.verification_flags, decision.level, 
+        // v3.4: restate the contract only when this prompt's Current Task IS
+        // the ACTIVE contract (derived — not the previous submission's field,
+        // which is a proposal and may differ from what this round executes).
+        activeContract != null, 
+        // v3.5: L2-only declaration nudge when nothing is active (policy-gated;
+        // mutually exclusive with the restate template above).
+        decision.level === "l2" && activeContract === null &&
+            getPolicy().prompt.contract_nudge_on_l2),
         fullStateMarkdown: l2Pointer ? undefined : markdown,
         // v2.9: Model's information needs from the previous round's SelfEvaluation
         promptRequests: request.last_round_result?.prompt_requests,