loopforge 3.2.1 → 3.7.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 { decodeRound, entryLineage, entryCriteriaMet, entryCriteriaRemaining, entryActiveConstraints, entryRetractedConstraints, entryProgressEstimate, entryEmergedSubtasks, 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";
@@ -15,17 +17,34 @@ function contextEntries(context) {
         return [];
     return context.results.filter((value) => value !== null && typeof value === "object" && !Array.isArray(value));
 }
-function lineage(entry) {
-    const value = entry.loop_lineage ?? entry.lineage;
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
 function loopEntries(loopId, context) {
     return contextEntries(context)
-        .filter((entry) => entry.loop_id === loopId || lineage(entry).loop_id === loopId)
+        .filter((entry) => entry.loop_id === loopId || entryLineage(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);
+}
 export function computeGoalTextHash(text) {
     const normalized = text.trim().replace(/\s+/g, " ").toLowerCase();
     return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
@@ -38,15 +57,13 @@ 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);
+    const data = entryLineage(entry);
     const constraintIds = data.presented_constraint_ids;
     const subGoals = data.presented_subgoals;
     const milestoneRanges = data.presented_milestone_ranges;
@@ -65,11 +82,10 @@ 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);
+    const data = entryLineage(entry);
     return {
         round,
         goal_id: typeof data.goal_id === "string" ? data.goal_id : "",
@@ -160,7 +176,7 @@ function evolveConstraints(request, objective, previous, context) {
     const lastRetractedRound = new Map();
     if (window > 0) {
         for (const entry of loopEntries(request.loop_id, context)) {
-            const retractedList = lineage(entry).retracted_constraints;
+            const retractedList = entryLineage(entry).retracted_constraints;
             if (!Array.isArray(retractedList))
                 continue;
             const rnd = entryRound(entry);
@@ -193,36 +209,6 @@ function evolveConstraints(request, objective, previous, context) {
 // ═══════════════════════════════════════════════════════════════════════════
 // Hierarchical Summary (v2.1)
 // ═══════════════════════════════════════════════════════════════════════════
-/** Extract execution_evidence from a vault entry, handling both direct-field
- *  and lineage-nested shapes. Returns null when absent. */
-function entryExecutionEvidence(entry) {
-    const direct = entry.execution_evidence;
-    if (direct && typeof direct === "object" && !Array.isArray(direct)) {
-        return direct;
-    }
-    const lin = lineage(entry);
-    const nested = lin.execution_evidence;
-    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-        return nested;
-    }
-    return null;
-}
-/** Read success_criteria_met from an entry's execution_evidence. */
-function entryCriteriaMet(entry) {
-    const ev = entryExecutionEvidence(entry);
-    if (!ev)
-        return [];
-    const arr = ev.success_criteria_met;
-    return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
-}
-/** Read success_criteria_remaining from an entry's execution_evidence. */
-function entryCriteriaRemaining(entry) {
-    const ev = entryExecutionEvidence(entry);
-    if (!ev)
-        return [];
-    const arr = ev.success_criteria_remaining;
-    return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
-}
 /** v3.2: Deterministic lessons learned — constraints violated repeatedly or
  *  verification checks failing repeatedly across rounds (full history, unlike
  *  the enforcement gate's R2 3-round window). Presentation only: the output
@@ -234,17 +220,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 = decodeRound(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 +263,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 +365,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 +385,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) {
@@ -357,37 +401,13 @@ function detectNewCriteria(current, previous) {
         return currMet;
     return currMet.filter((curr) => prevMet.every((prev) => !criteriaMatch(curr, prev)));
 }
-/** Read constraints_active from an entry's lineage. */
-function entryActiveConstraints(entry) {
-    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 direct = entry.retracted_constraints;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    const lin = lineage(entry);
-    const nested = lin.retracted_constraints;
-    if (Array.isArray(nested))
-        return nested.filter((v) => typeof v === "string");
-    return [];
-}
-/** Read progress_estimate from an entry's execution_evidence. */
-function entryProgressEstimate(entry) {
-    const ev = entryExecutionEvidence(entry);
-    if (!ev)
-        return 0;
-    const pe = ev.progress_estimate;
-    return typeof pe === "number" ? pe : 0;
-}
 /** 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 ? decodeRound(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 +488,29 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
     const outcomes = [];
     const issues = [];
     for (const entry of windowEntries) {
-        const data = lineage(entry);
+        const view = decodeRound(entry);
+        const data = entryLineage(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 ──
@@ -497,7 +522,7 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
     for (let i = 0; i < completedEntries.length; i++) {
         const entry = completedEntries[i];
         const rnd = entryRound(entry);
-        const lin = lineage(entry);
+        const lin = entryLineage(entry);
         // Signal 1: Agent-declared checkpoint
         const isAgentCheckpoint = lin.compression_checkpoint === true;
         // Signal 2: New criteria met (compare with previous vault entry)
@@ -521,10 +546,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 +572,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 +581,6 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
         generated_at_round: currentRound,
         failed_patterns: [],
         milestones: cappedMilestones,
-        loop_synthesis: loopSynthesis || undefined,
     });
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -587,48 +601,13 @@ export function deriveConstraintId(text) {
 export function deriveCriterionId(text) {
     return "cr-" + deriveItemId(text);
 }
-/** v2.11: Check whether a user-provided reference looks like a constraint ID.
- *  Matches the pattern c-XXXXXXXX where X is a hex digit. */
-export function isConstraintId(ref) {
-    return /^c-[a-f0-9]{8}$/.test(ref);
-}
 /** v2.11: Check whether a user-provided reference looks like a criterion ID.
- *  Matches the pattern cr-XXXXXXXX where X is a hex digit. */
-export function isCriterionId(ref) {
+ *  Matches the pattern cr-XXXXXXXX where X is a hex digit. Module-local:
+ *  consumers with the same need (round-contract.ts) keep their own copy to
+ *  avoid an import cycle. */
+function isCriterionId(ref) {
     return /^cr-[a-f0-9]{8}$/.test(ref);
 }
-/** Read emerged_subtasks from a vault entry (handles direct + lineage nesting). */
-function entryEmergedSubtasks(entry) {
-    const direct = entry.emerged_subtasks;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    const lin = lineage(entry);
-    const nested = lin.emerged_subtasks;
-    if (Array.isArray(nested))
-        return nested.filter((v) => typeof v === "string");
-    return [];
-}
-/** Read completed_subtasks from an entry. */
-function entryCompletedSubtasks(entry) {
-    const direct = entry.completed_subtasks;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    return [];
-}
-/** Read blocked_subtasks from an entry. */
-function entryBlockedSubtasks(entry) {
-    const direct = entry.blocked_subtasks;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    return [];
-}
-/** Read canceled_subtasks from an entry. */
-function entryCanceledSubtasks(entry) {
-    const direct = entry.canceled_subtasks;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    return [];
-}
 /**
  * Match a user-provided sub-task reference against existing SubGoals.
  *
@@ -736,35 +715,10 @@ function manageSubGoals(loopId, currentRound, lastRoundResult, vaultContext) {
                 subGoals[idx].status_changed_at_round = rnd;
             }
         }
-        // Phase 3 — Auto-derive: next_action match → in_progress
-        const nextAction = lastRoundResult.next_action?.trim();
-        if (nextAction) {
-            for (const sg of subGoals) {
-                if (sg.status === "pending") {
-                    if (jaccardSimilarity(nextAction, sg.description) >= policy.subgoal_auto_in_progress_threshold) {
-                        sg.status = "in_progress";
-                        sg.status_changed_at_round = rnd;
-                        break; // Only one sub-goal can be in_progress at a time
-                    }
-                }
-            }
-        }
-        // Phase 4 — Auto-complete: new criteria match → done
-        const newCriteria = lastRoundResult.execution_evidence?.success_criteria_met ?? [];
-        if (newCriteria.length > 0) {
-            for (const sg of subGoals) {
-                if (sg.status === "pending" || sg.status === "in_progress") {
-                    for (const crit of newCriteria) {
-                        if (jaccardSimilarity(crit, sg.description) >= policy.subgoal_auto_complete_threshold) {
-                            sg.status = "done";
-                            sg.status_changed_at_round = rnd;
-                            sg.completed_at_round = rnd;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
+        // v3.7: no auto status inference. The v2.3 fuzzy heuristics
+        // (next_action Jaccard → in_progress, criteria Jaccard → done) were
+        // removed — they fabricated dashboard motion the machine never
+        // verified. Statuses change only via the agent declarations above.
     }
     // Sort for display: in_progress first, then pending by age desc, then blocked, then done, then canceled
     subGoals.sort((a, b) => {
@@ -805,37 +759,6 @@ function constraintSource(text, objective, constraintsFromPlan) {
         return "criteria";
     return "discovered";
 }
-/** Find the earliest round a constraint was discovered by scanning vault entries.
- *  v2.11: ID-first matching. Checks exact constraint ID match (c-XXXXXXXX)
- *  against the derived ID of each vault entry's discovered_constraints, then
- *  falls back to Jaccard similarity on text. */
-function findDiscoveredRound(text, vaultEntries) {
-    const targetId = deriveConstraintId(text);
-    let earliest = 0;
-    for (const entry of vaultEntries) {
-        const rnd = entryRound(entry);
-        if (rnd < 1)
-            continue;
-        const discovered = 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) {
-                if (earliest === 0 || rnd < earliest)
-                    earliest = rnd;
-                break;
-            }
-            // Phase 2: Jaccard fallback (backward compatibility)
-            if (jaccardSimilarity(text, d) >= getPolicy().evolution.constraint_match_threshold) {
-                if (earliest === 0 || rnd < earliest)
-                    earliest = rnd;
-                break;
-            }
-        }
-    }
-    return earliest;
-}
 /** Find the latest round a constraint was violated by scanning vault entries.
  *  v2.11: ID-first matching. Checks exact constraint ID match (c-XXXXXXXX)
  *  against the derived ID of each vault entry's constraint_violations, then
@@ -856,9 +779,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 = decodeRound(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)
@@ -870,15 +796,17 @@ function findLastViolatedRound(text, vaultEntries) {
     return latest;
 }
 /**
- * Manage constraint lifecycle with time-aware decay.
+ * Manage constraint lifecycle metadata for the active set.
  *
- * Discovered constraints that haven't been violated for N rounds are demoted
- * to inactive — removed from prompts but kept in state. Hard/plan/criteria
- * constraints never auto-decay. Inactive constraints are auto-reactivated
- * if violated again in the current round.
+ * v3.7: the v2.3 time-aware decay (discovered constraints demoted to
+ * inactive after N quiet rounds, auto-reactivation on a fresh violation)
+ * is gone — every active constraint stays active. What remains is the
+ * display metadata the v3 prompt surface needs: per-text source
+ * classification (v3.3.1: criteria texts carry the cr-XXXXXXXX namespace),
+ * and last_violated_at_round for the L1 collapse "(violated this round)"
+ * annotation (diffConstraints compares it to the current round).
  */
 function manageConstraintLifecycle(active, objective, constraintsFromPlan, vaultContext, currentRound, lastRoundViolations = []) {
-    const policy = getPolicy().evolution;
     const allEntries = loopEntries(objective.loop_id || "", vaultContext);
     const completedEntries = allEntries.filter((e) => entryRound(e) >= 1 && entryRound(e) < currentRound);
     const metadata = [];
@@ -888,50 +816,25 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
         // as a violation at currentRound — the previous rounds' scan cannot see
         // it (this round is not committed yet). This makes the L1 collapse
         // render "(violated this round)" (diffConstraints compares
-        // last_violated_at_round === round) and re-activates decayed
-        // discovered constraints.
+        // last_violated_at_round === round).
         const violatedThisRound = lastRoundViolations.some((v) => matchesConstraintText(text, v));
-        // Structural constraints never decay
-        if (source === "hard" || source === "plan" || source === "criteria") {
-            metadata.push(makeConstraintMeta({
-                id: deriveConstraintId(text),
-                text,
-                discovered_at_round: objective.created_at_round || 1,
-                last_violated_at_round: violatedThisRound
-                    ? currentRound
-                    : findLastViolatedRound(text, completedEntries),
-                source,
-                status: "active",
-            }));
-            continue;
-        }
-        // Discovered constraints: check for inactivity
-        const discoveredAt = findDiscoveredRound(text, completedEntries);
-        const lastViolated = violatedThisRound
-            ? currentRound
-            : findLastViolatedRound(text, completedEntries);
-        const roundsSinceRelevant = lastViolated > 0
-            ? currentRound - lastViolated
-            : currentRound - (discoveredAt || currentRound);
-        const status = roundsSinceRelevant > policy.constraint_inactive_rounds
-            ? "inactive"
-            : "active";
+        // 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: discoveredAt || 0,
-            last_violated_at_round: lastViolated,
-            source: "discovered",
-            status,
+            last_violated_at_round: violatedThisRound
+                ? currentRound
+                : findLastViolatedRound(text, completedEntries),
+            source,
         }));
     }
-    const newActive = metadata
-        .filter((m) => m.status === "active")
-        .map((m) => m.text);
-    const inactive = metadata
-        .filter((m) => m.status === "inactive")
-        .map((m) => m.text);
-    return { active: newActive, inactive, metadata };
+    return { active, metadata };
 }
 export function alignTask(proposedTask, request, context) {
     const objective = request.loop_objective ?? latestObjective(request.loop_id, context);
@@ -976,7 +879,7 @@ function levelDecision(request, context) {
         last?.revised_success_criteria?.length ||
         last?.wrong_assumptions?.length);
     const lastFullRound = loopEntries(request.loop_id, context)
-        .filter((entry) => lineage(entry).recompile_level === "l2")
+        .filter((entry) => entryLineage(entry).recompile_level === "l2")
         .map(entryRound)
         .filter((round) => round < request.round)
         .at(-1) ?? 1;
@@ -985,7 +888,7 @@ function levelDecision(request, context) {
     // rehydration (the decidePromptLevel recovery_boundary branch existed
     // but no caller ever set it).
     const recoveryBoundary = loopEntries(request.loop_id, context)
-        .some((entry) => lineage(entry).committed_action === "backtrack" &&
+        .some((entry) => entryLineage(entry).committed_action === "backtrack" &&
         entryRound(entry) === request.round);
     return decidePromptLevel({
         round: request.round,
@@ -1011,11 +914,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 +958,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 +987,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 +1042,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,
@@ -1120,7 +1065,6 @@ export function compileLoop(request, context) {
         lineage: [`${request.loop_id}:r${request.round}`],
         constraints_active: constraintLifecycle.active,
         constraints_retired: constraints.retired,
-        constraints_inactive: constraintLifecycle.inactive,
         constraint_metadata: constraintLifecycle.metadata,
         loop_id: request.loop_id,
         round: request.round,
@@ -1142,7 +1086,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
@@ -1159,14 +1108,21 @@ export function compileLoop(request, context) {
         state,
         level: decision.level,
         reasons: decision.reasons,
-        mode: policy.prompt.injection_mode,
         budgets: {
             l0: policy.prompt.l0_max_chars,
             l1: policy.prompt.l1_max_chars,
             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,