loopforge 2.11.0 → 3.2.1

package/dist/loop-compiler.js

@@ -9,7 +9,7 @@ import { AgentStatus, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective
 import { createCanonicalLoopState, renderCanonicalStateMarkdown, } from "./canonical-state.js";
 import { assemblePromptArtifact } from "./prompt-assembler.js";
 import { decidePromptLevel, } from "./prompt-policy.js";
-import { jaccardSimilarity, unique, entryRound } from "./token-utils.js";
+import { deriveItemId, jaccardSimilarity, unique, entryRound } from "./token-utils.js";
 function contextEntries(context) {
     if (!context || !Array.isArray(context.results))
         return [];
@@ -36,6 +36,34 @@ export function deriveGoalId(loopId, task, explicit = "") {
         .replace(/^-|-$/g, "")
         .slice(0, 48) || computeGoalTextHash(task)}`;
 }
+/** 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. */
+export function readPresentedBaseline(loopId, round, context) {
+    const entry = [...loopEntries(loopId, context)].reverse()
+        .find((candidate) => entryRound(candidate) === round - 1);
+    if (!entry)
+        return null;
+    const data = lineage(entry);
+    const constraintIds = data.presented_constraint_ids;
+    const subGoals = data.presented_subgoals;
+    const milestoneRanges = data.presented_milestone_ranges;
+    if (!Array.isArray(constraintIds) || !constraintIds.every((v) => typeof v === "string") ||
+        !Array.isArray(subGoals) || !subGoals.every((v) => Array.isArray(v) && v.length === 2 &&
+        typeof v[0] === "string" && typeof v[1] === "string") ||
+        !Array.isArray(milestoneRanges) || !milestoneRanges.every((v) => Array.isArray(v) && v.length === 2 &&
+        typeof v[0] === "number" && typeof v[1] === "number")) {
+        return null;
+    }
+    return {
+        round: round - 1,
+        constraintIds: constraintIds,
+        subGoals: subGoals,
+        milestoneRanges: milestoneRanges,
+    };
+}
 export function getPreviousRound(loopId, round, context) {
     const entry = [...loopEntries(loopId, context)].reverse()
         .find((candidate) => entryRound(candidate) === round);
@@ -115,19 +143,51 @@ function evolveObjective(request, context) {
         loop_id: request.loop_id,
     });
 }
-function evolveConstraints(request, objective, previous) {
+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 ?? [])
         .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).
+    const window = getPolicy().constraints.retire_window;
+    const lastRetractedRound = new Map();
+    if (window > 0) {
+        for (const entry of loopEntries(request.loop_id, context)) {
+            const retractedList = lineage(entry).retracted_constraints;
+            if (!Array.isArray(retractedList))
+                continue;
+            const rnd = entryRound(entry);
+            for (const text of retractedList) {
+                if (typeof text !== "string" || !text)
+                    continue;
+                const prev = lastRetractedRound.get(text);
+                if (prev === undefined || rnd > prev)
+                    lastRetractedRound.set(text, rnd);
+            }
+        }
+    }
     const active = unique([
         ...(previous?.constraints_active ?? []),
         ...request.constraints_from_plan,
         ...objective.hard_constraints,
         ...objective.success_criteria,
         ...discovered,
-    ]).filter((item) => !retiredSet.has(item))
-        .slice(0, getPolicy().evolution.max_active_constraints);
+    ]).filter((item) => {
+        if (retiredSet.has(item))
+            return false;
+        const retractedRound = lastRetractedRound.get(item);
+        if (retractedRound !== undefined && request.round - retractedRound < window) {
+            return false;
+        }
+        return true;
+    }).slice(0, getPolicy().evolution.max_active_constraints);
     return { active, retired };
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -155,6 +215,112 @@ function entryCriteriaMet(entry) {
     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
+ *  never feeds enforcement decisions. */
+export function deriveLessons(loopId, context, currentRound) {
+    const entries = loopEntries(loopId, context).filter((entry) => entryRound(entry) >= 1 && entryRound(entry) < currentRound);
+    const violations = new Map();
+    const errors = new Map();
+    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")
+            : [];
+        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
+            : [];
+        for (const flag of flags) {
+            const target = flag.severity === "error"
+                ? errors
+                : flag.severity === "warn" ? warns : null;
+            if (!target)
+                continue;
+            const list = target.get(flag.check) ?? [];
+            list.push(rnd);
+            target.set(flag.check, list);
+        }
+    }
+    const lessons = [];
+    for (const [text, rounds] of violations) {
+        if (rounds.length >= 2) {
+            lessons.push({ text, kind: "constraint_violation", count: rounds.length, rounds });
+        }
+    }
+    for (const [text, rounds] of errors) {
+        if (rounds.length >= 2) {
+            lessons.push({ text, kind: "verification_error", count: rounds.length, rounds });
+        }
+    }
+    for (const [text, rounds] of warns) {
+        if (rounds.length >= 2) {
+            lessons.push({ text, kind: "verification_warning", count: rounds.length, rounds });
+        }
+    }
+    return lessons.sort((a, b) => b.count - a.count);
+}
+/** 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
+ *  matching), the round it was first reported met, and any sub-goals whose
+ *  description matches it (Jaccard). Zero persistence — re-derived from the
+ *  vault every compile. */
+export function deriveCriterionStatuses(loopId, context, objective, currentRound, subGoals, lastRoundResult) {
+    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.
+    const lastEv = lastRoundResult?.execution_evidence;
+    const lastMet = lastEv?.success_criteria_met ?? [];
+    const lastRemaining = lastEv?.success_criteria_remaining ?? [];
+    const lastEntry = entries[entries.length - 1] ?? null;
+    const lastEntryRemaining = lastEntry ? entryCriteriaRemaining(lastEntry) : [];
+    const matchThreshold = getPolicy().evolution.subgoal_match_threshold;
+    return objective.success_criteria.map((text) => {
+        let metAtRound = null;
+        for (const entry of entries) {
+            const rnd = entryRound(entry);
+            if (entryCriteriaMet(entry).some((met) => criteriaMatch(met, text))) {
+                metAtRound = rnd;
+                break; // first report wins — chronological scan
+            }
+        }
+        if (metAtRound === null && lastMet.some((met) => criteriaMatch(met, text))) {
+            metAtRound = currentRound - 1;
+        }
+        const status = metAtRound !== null
+            ? "met"
+            : lastRemaining.some((remaining) => criteriaMatch(remaining, text)) ||
+                lastEntryRemaining.some((remaining) => criteriaMatch(remaining, text))
+                ? "remaining"
+                : "unknown";
+        return {
+            id: deriveCriterionId(text),
+            text,
+            status,
+            ...(metAtRound !== null ? { met_at_round: metAtRound } : {}),
+            related_subgoal_ids: subGoals
+                .filter((sg) => jaccardSimilarity(text, sg.description) >= matchThreshold)
+                .map((sg) => sg.id),
+        };
+    });
+}
 /** 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. */
@@ -240,7 +406,56 @@ function buildMilestoneFromEntries(phaseEntries, startRound, endRound, label, ki
         generated_at_round: endRound,
     });
 }
-export function buildRollingSummary(loopId, currentRound, context, sinceRound = 0) {
+/** v3.0.1: Evenly sample `budget` entries from `mid`, preferring
+ *  agent_declared milestones (human/agent-labeled anchors) first and filling
+ *  the remainder at even time positions. The caller guarantees
+ *  `mid.length > budget`. */
+function sampleMiddleMilestones(mid, budget) {
+    if (budget <= 0)
+        return [];
+    if (mid.length <= budget)
+        return mid;
+    const chosen = [];
+    const used = new Set();
+    for (const m of mid) {
+        if (m.kind === "agent_declared") {
+            chosen.push(m);
+            used.add(m);
+            if (chosen.length >= budget)
+                return chosen;
+        }
+    }
+    const rest = mid.filter((m) => !used.has(m));
+    const need = budget - chosen.length;
+    for (let i = 0; i < need; i++) {
+        const idx = Math.floor(((i + 0.5) * rest.length) / need);
+        chosen.push(rest[idx]);
+    }
+    return chosen;
+}
+/** v3.0.1: L1 milestone sampling — when milestones exceed max_milestones,
+ *  keep the oldest `milestone_head_count` (history anchors), the newest
+ *  `milestone_tail_count` (current progress), and an even sample of the
+ *  middle. L2 (full rehydration) is never sampled: the recovery view keeps
+ *  every milestone as the loop's memory skeleton. */
+function sampleMilestones(milestones, policy, level) {
+    if (level === "l2")
+        return milestones;
+    if (milestones.length <= policy.max_milestones)
+        return milestones;
+    const head = Math.max(0, policy.milestone_head_count);
+    const tail = Math.max(0, policy.milestone_tail_count);
+    const midBudget = Math.max(0, policy.max_milestones - head - tail);
+    if (midBudget === 0)
+        return milestones.slice(0, head).concat(milestones.slice(milestones.length - tail));
+    const mid = milestones.slice(head, milestones.length - tail);
+    return [
+        ...milestones.slice(0, head),
+        ...sampleMiddleMilestones(mid, midBudget),
+        ...milestones.slice(milestones.length - tail),
+    ];
+}
+export function buildRollingSummary(loopId, currentRound, context, sinceRound = 0, level) {
     const policy = getPolicy().summary;
     const allEntries = loopEntries(loopId, context);
     // ── Phase 1: Recent Window (preserves existing behavior) ──
@@ -259,8 +474,15 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
         const summary = 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 outcomeLabel = declared === "success" || declared === "partial" ||
+            declared === "failed" || declared === "blocked"
+            ? declared
+            : success === false ? "failed" : "accepted";
         if (summary)
-            outcomes.push(`[R${round}] ${success === false ? "failed" : "accepted"}: ${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 : [];
@@ -314,7 +536,10 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
             milestones.push(buildMilestoneFromEntries(phaseEntries, startRound, endRound, `Rounds ${startRound}–${endRound}`, "auto"));
         }
     }
-    const cappedMilestones = milestones.slice(-policy.max_milestones);
+    // v3.0.1: L1 keeps head anchors + newest tail + an even middle sample;
+    // 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) {
@@ -347,28 +572,29 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
 // ═══════════════════════════════════════════════════════════════════════════
 // Sub-Goal Structured Tracking (v2.2)
 // ═══════════════════════════════════════════════════════════════════════════
-/** Derive a stable sub-goal ID from its description hash. */
-function deriveSubGoalId(description) {
-    return "sg-" + computeGoalTextHash(description).slice(0, 8);
+/** Derive a stable sub-goal ID from its description hash.
+ *  Exported as the single source of truth (verification-gate imports it). */
+export function deriveSubGoalId(description) {
+    return "sg-" + deriveItemId(description);
 }
 /** v2.11: Derive a stable constraint ID from its text hash (c-XXXXXXXX).
  *  Same hash strategy as SubGoal — deterministic across rounds. */
-function deriveConstraintId(text) {
-    return "c-" + computeGoalTextHash(text).slice(0, 8);
+export function deriveConstraintId(text) {
+    return "c-" + deriveItemId(text);
 }
 /** v2.11: Derive a stable criterion ID from its text hash (cr-XXXXXXXX).
  *  Same hash strategy as SubGoal — deterministic across rounds. */
-function deriveCriterionId(text) {
-    return "cr-" + computeGoalTextHash(text).slice(0, 8);
+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. */
-function isConstraintId(ref) {
+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. */
-function isCriterionId(ref) {
+export function isCriterionId(ref) {
     return /^cr-[a-f0-9]{8}$/.test(ref);
 }
 /** Read emerged_subtasks from a vault entry (handles direct + lineage nesting). */
@@ -555,8 +781,10 @@ function manageSubGoals(loopId, currentRound, lastRoundResult, vaultContext) {
         if (ra !== rb)
             return ra - rb;
         // Within same status: pending by oldest first, done by most recent first
+        // (v2.14: the previous expression simplified to b.declared - a.declared,
+        // which sorted NEWEST first despite the comment)
         if (a.status === "pending")
-            return (currentRound - a.declared_at_round) - (currentRound - b.declared_at_round);
+            return a.declared_at_round - b.declared_at_round;
         if (a.status === "done")
             return (b.completed_at_round ?? 0) - (a.completed_at_round ?? 0);
         return a.declared_at_round - b.declared_at_round;
@@ -612,8 +840,17 @@ function findDiscoveredRound(text, vaultEntries) {
  *  v2.11: ID-first matching. Checks exact constraint ID match (c-XXXXXXXX)
  *  against the derived ID of each vault entry's constraint_violations, then
  *  falls back to Jaccard similarity on text. Returns 0 if never violated. */
-function findLastViolatedRound(text, vaultEntries) {
+/** True when a reported violation text matches a constraint text — same
+ *  ID-first + Jaccard fallback matching as findLastViolatedRound. */
+function matchesConstraintText(text, violation) {
     const targetId = deriveConstraintId(text);
+    if (violation === targetId || deriveConstraintId(violation) === targetId) {
+        return true;
+    }
+    return jaccardSimilarity(text, violation) >=
+        getPolicy().evolution.constraint_match_threshold;
+}
+function findLastViolatedRound(text, vaultEntries) {
     let latest = 0;
     for (const entry of vaultEntries) {
         const rnd = entryRound(entry);
@@ -623,14 +860,7 @@ function findLastViolatedRound(text, vaultEntries) {
             ? entry.constraint_violations.filter((v) => typeof v === "string")
             : [];
         for (const v of violations) {
-            // Phase 1: exact ID match (v2.11)
-            if (v === targetId || deriveConstraintId(v) === targetId) {
-                if (rnd > latest)
-                    latest = rnd;
-                break;
-            }
-            // Phase 2: Jaccard fallback (backward compatibility)
-            if (jaccardSimilarity(text, v) >= getPolicy().evolution.constraint_match_threshold) {
+            if (matchesConstraintText(text, v)) {
                 if (rnd > latest)
                     latest = rnd;
                 break;
@@ -647,20 +877,29 @@ function findLastViolatedRound(text, vaultEntries) {
  * constraints never auto-decay. Inactive constraints are auto-reactivated
  * if violated again in the current round.
  */
-function manageConstraintLifecycle(active, objective, constraintsFromPlan, vaultContext, currentRound) {
+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 = [];
     for (const text of active) {
         const source = constraintSource(text, objective, constraintsFromPlan);
+        // v3.2.1: a violation reported in THIS round (last_round_result) counts
+        // 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.
+        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: findLastViolatedRound(text, completedEntries),
+                last_violated_at_round: violatedThisRound
+                    ? currentRound
+                    : findLastViolatedRound(text, completedEntries),
                 source,
                 status: "active",
             }));
@@ -668,7 +907,9 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
         }
         // Discovered constraints: check for inactivity
         const discoveredAt = findDiscoveredRound(text, completedEntries);
-        const lastViolated = findLastViolatedRound(text, completedEntries);
+        const lastViolated = violatedThisRound
+            ? currentRound
+            : findLastViolatedRound(text, completedEntries);
         const roundsSinceRelevant = lastViolated > 0
             ? currentRound - lastViolated
             : currentRound - (discoveredAt || currentRound);
@@ -696,12 +937,14 @@ export function alignTask(proposedTask, request, context) {
     const objective = request.loop_objective ?? latestObjective(request.loop_id, context);
     if (!objective)
         return makeTaskAlignment();
+    // v2.14: threshold is policy-driven (evolution.progress_mismatch_threshold)
+    const threshold = getPolicy().evolution.progress_mismatch_threshold;
     const score = jaccardSimilarity(proposedTask, [objective.objective, ...objective.success_criteria, ...objective.hard_constraints].join(" "));
     return makeTaskAlignment({
-        is_aligned: score >= 0.3,
+        is_aligned: score >= threshold,
         alignment_score: Number(score.toFixed(2)),
-        warning: score < 0.3 ? "Current task may be drifting from the loop objective." : "",
-        escalation: score < 0.3 ? "warn" : "none",
+        warning: score < threshold ? "Current task may be drifting from the loop objective." : "",
+        escalation: score < threshold ? "warn" : "none",
     });
 }
 export function checkLoopHealth(loopId, request, context) {
@@ -710,7 +953,9 @@ export function checkLoopHealth(loopId, request, context) {
     const violations = request.last_round_result?.constraint_violations.length ?? 0;
     const integrity = Math.max(0, 1 - violations * 0.2);
     const continuity = previous ? jaccardSimilarity(previous.task, request.task) : 1;
-    const drift = alignment.alignment_score < 0.3 || continuity < 0.2;
+    // v2.14: thresholds are policy-driven
+    const drift = alignment.alignment_score < getPolicy().evolution.progress_mismatch_threshold ||
+        continuity < getPolicy().evolution.task_continuity_threshold;
     return makeLoopHealth({
         goal_alignment: alignment.alignment_score,
         constraint_integrity: integrity,
@@ -735,11 +980,19 @@ function levelDecision(request, context) {
         .map(entryRound)
         .filter((round) => round < request.round)
         .at(-1) ?? 1;
+    // 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) => lineage(entry).committed_action === "backtrack" &&
+        entryRound(entry) === request.round);
     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,
@@ -754,10 +1007,15 @@ function levelDecision(request, context) {
 export function decideLevel(request, context) {
     return levelDecision(request, context).level;
 }
-export function buildSelfEvalBlock(round, prevDriftFlags) {
+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) {
     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 evalObj = {
         success: false,
         output_summary: `<verified result of round ${round}>`,
@@ -778,6 +1036,12 @@ export function buildSelfEvalBlock(round, prevDriftFlags) {
         blocked_subtasks: ["<sg-XXXXXXXX or text>"],
         canceled_subtasks: ["<sg-XXXXXXXX or text>"],
     };
+    // v2.12: Declarative tri-state outcome (L1/L2 only — keeps L0 retry lean)
+    if (declareOutcome) {
+        evalObj.outcome = "<success|partial|failed|blocked>";
+        evalObj.blocker = "<required only when outcome=blocked>";
+        evalObj.retroactiveClaims = [];
+    }
     // v2.8: Inject drift clarification field when previous round had drift flags
     if (needsClarification) {
         const flagTypes = [
@@ -815,10 +1079,14 @@ 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);
-    const constraintLifecycle = manageConstraintLifecycle(constraints.active, objective, request.constraints_from_plan, context, request.round);
-    const rolling = buildRollingSummary(request.loop_id, request.round, 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, decision.level);
     const subGoals = manageSubGoals(request.loop_id, request.round, request.last_round_result, context);
+    // v3.2: Goal → criteria → evidence vertical view (derived, zero persistence).
+    const criterionStatuses = deriveCriterionStatuses(request.loop_id, context, objective, request.round, subGoals, request.last_round_result);
+    // v3.2: Lessons learned — repeated violations / verification failures.
+    const lessons = deriveLessons(request.loop_id, context, request.round);
     const alignment = alignTask(request.task, request, context);
     const health = checkLoopHealth(request.loop_id, { ...request, loop_objective: objective }, context);
     const warnings = unique([
@@ -863,6 +1131,8 @@ export function compileLoop(request, context) {
         task_alignment: alignment,
         rolling_summary: rolling,
         sub_goals: subGoals,
+        criterion_statuses: criterionStatuses,
+        lessons,
         agent_trust_score: request.round > 1 ? Number(trustScore.toFixed(2)) : undefined,
         agent_trust_trend: request.round > 1 ? trend : [],
         suggested_next_task: request.last_round_result?.next_action?.trim() ||
@@ -896,10 +1166,12 @@ export function compileLoop(request, context) {
             l2: adaptiveL2,
         },
         attempt: request.attempt,
-        selfEvaluationBlock: buildSelfEvalBlock(request.round, request.verification_flags),
+        selfEvaluationBlock: buildSelfEvalBlock(request.round, request.verification_flags, decision.level),
         fullStateMarkdown: l2Pointer ? undefined : markdown,
         // v2.9: Model's information needs from the previous round's SelfEvaluation
         promptRequests: request.last_round_result?.prompt_requests,
+        // v3.2: Previous L1 presentation as the collapse diff baseline.
+        presentedBaseline: readPresentedBaseline(request.loop_id, request.round, context),
     });
     response.prompt = artifact.renderedPrompt;
     response.prompt_artifact = artifact;