loopforge 2.0.1 → 2.6.0

package/dist/loop-compiler.js

@@ -5,16 +5,12 @@
  */
 import { createHash } from "node:crypto";
 import { getPolicy } from "./policy.js";
-import { AgentStatus, makeCheckpointSummary, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeRollingSummary, makeTaskAlignment, } from "./protocol.js";
+import { AgentStatus, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, makeSubGoal, makeTaskAlignment, } from "./protocol.js";
 import { createCanonicalLoopState, renderCanonicalStateMarkdown, } from "./canonical-state.js";
 import { assemblePromptArtifact } from "./prompt-assembler.js";
 import { decidePromptLevel, } from "./prompt-policy.js";
-function unique(values) {
-    return [...new Set(values
-            .filter((value) => typeof value === "string")
-            .map((value) => value.trim())
-            .filter(Boolean))];
-}
+import { jaccardSimilarity, unique, entryRound } from "./token-utils.js";
+// unique() imported from token-utils.ts
 function contextEntries(context) {
     if (!context || !Array.isArray(context.results))
         return [];
@@ -26,10 +22,7 @@ function lineage(entry) {
         ? value
         : {};
 }
-function entryRound(entry) {
-    const value = lineage(entry).round;
-    return typeof value === "number" ? value : 0;
-}
+// entryRound() imported from token-utils.ts
 function loopEntries(loopId, context) {
     return contextEntries(context)
         .filter((entry) => entry.loop_id === loopId || lineage(entry).loop_id === loopId)
@@ -139,19 +132,111 @@ function evolveConstraints(request, objective, previous) {
         .slice(0, getPolicy().evolution.max_active_constraints);
     return { active, retired };
 }
+// ═══════════════════════════════════════════════════════════════════════════
+// 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") : [];
+}
+/** Detect newly met criteria by comparing the current entry's
+ *  success_criteria_met against the previous entry's, using Jaccard
+ *  similarity with threshold 0.7 to avoid Surface-form mismatches.
+ *  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) {
+    const currMet = entryCriteriaMet(current);
+    if (currMet.length === 0)
+        return [];
+    if (!previous) {
+        // First round with criteria is the baseline — not a milestone trigger.
+        return [];
+    }
+    const prevMet = entryCriteriaMet(previous);
+    if (prevMet.length === 0)
+        return currMet;
+    return currMet.filter((curr) => prevMet.every((prev) => jaccardSimilarity(curr, prev) < getPolicy().evolution.criteria_dedup_threshold));
+}
+/** 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 outcomeMax = getPolicy().checkpoint.outcome_max_chars;
+    const outcome = outcomeRaw.length > outcomeMax
+        ? outcomeRaw.slice(0, outcomeMax) + "…"
+        : outcomeRaw;
+    const carried = last ? entryActiveConstraints(last) : [];
+    const resolved = unique(phaseEntries.flatMap((e) => entryRetractedConstraints(e)));
+    const progress = last ? entryProgressEstimate(last) : 0;
+    return makeMilestoneSummary({
+        label,
+        round_range: { start: startRound, end: endRound },
+        outcome,
+        carried_constraints: carried,
+        resolved_constraints: resolved,
+        progress_at_boundary: progress,
+        kind,
+        generated_at_round: endRound,
+    });
+}
 export function buildRollingSummary(loopId, currentRound, context, sinceRound = 0) {
-    const window = getPolicy().summary.window;
-    const entries = loopEntries(loopId, context)
+    const policy = getPolicy().summary;
+    const allEntries = loopEntries(loopId, context);
+    // ── Phase 1: Recent Window (preserves existing behavior) ──
+    const windowEntries = allEntries
         .filter((entry) => {
         const round = entryRound(entry);
         return round >= sinceRound && round < currentRound;
     })
-        .slice(-window);
-    if (entries.length === 0)
-        return null;
+        .slice(-policy.window);
     const outcomes = [];
     const issues = [];
-    for (const entry of entries) {
+    for (const entry of windowEntries) {
         const data = lineage(entry);
         const round = entryRound(entry);
         const success = entry.success ?? data.success;
@@ -165,33 +250,387 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
             : Array.isArray(data.constraint_violations) ? data.constraint_violations : [];
         issues.push(...violations.filter((item) => typeof item === "string"));
     }
+    // ── Phase 2: Milestone Accumulation ──
+    // Scan all completed entries in round order. For each entry, check three
+    // trigger signals in priority order: agent_declared > criteria_milestone > auto.
+    const completedEntries = allEntries.filter((entry) => entryRound(entry) >= 1 && entryRound(entry) < currentRound);
+    const milestones = [];
+    let lastMilestoneRound = 0;
+    for (let i = 0; i < completedEntries.length; i++) {
+        const entry = completedEntries[i];
+        const rnd = entryRound(entry);
+        const lin = lineage(entry);
+        // Signal 1: Agent-declared checkpoint
+        const isAgentCheckpoint = lin.compression_checkpoint === true;
+        // Signal 2: New criteria met (compare with previous vault entry)
+        const prev = i > 0 ? completedEntries[i - 1] : null;
+        const newCriteria = detectNewCriteria(entry, prev);
+        if (isAgentCheckpoint || newCriteria.length > 0) {
+            const startRound = lastMilestoneRound + 1;
+            const phaseEntries = completedEntries.filter((e) => {
+                const er = entryRound(e);
+                return er >= startRound && er <= rnd;
+            });
+            const kind = isAgentCheckpoint
+                ? "agent_declared"
+                : "criteria_milestone";
+            const label = isAgentCheckpoint
+                ? (typeof lin.checkpoint_label === "string" && lin.checkpoint_label.trim()
+                    ? lin.checkpoint_label.trim()
+                    : `Round ${rnd}`)
+                : `Completed: ${newCriteria.join(", ")}`;
+            milestones.push(buildMilestoneFromEntries(phaseEntries, startRound, rnd, label, kind));
+            lastMilestoneRound = rnd;
+        }
+    }
+    // Signal 3: Safety net — auto milestone when gap exceeds milestone_interval
+    const gapSinceLast = (currentRound - 1) - lastMilestoneRound;
+    if (lastMilestoneRound > 0 &&
+        gapSinceLast >= policy.milestone_interval &&
+        completedEntries.length > 0) {
+        const startRound = lastMilestoneRound + 1;
+        const endRound = currentRound - 1;
+        const phaseEntries = completedEntries.filter((e) => {
+            const er = entryRound(e);
+            return er >= startRound && er <= endRound;
+        });
+        if (phaseEntries.length > 0) {
+            milestones.push(buildMilestoneFromEntries(phaseEntries, startRound, endRound, `Rounds ${startRound}–${endRound}`, "auto"));
+        }
+    }
+    const cappedMilestones = milestones.slice(-policy.max_milestones);
+    // ── 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({
         key_outcomes: unique(outcomes),
         recurring_issues: unique(issues),
-        rounds_sampled: entries.length,
+        rounds_sampled: windowEntries.length,
         generated_at_round: currentRound,
         failed_patterns: [],
+        milestones: cappedMilestones,
+        loop_synthesis: loopSynthesis || undefined,
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// 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);
+}
+/** 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 description against existing SubGoals.
+ * Returns the index of the best-matching SubGoal with similarity >= threshold,
+ * or -1 if no match found.
+ */
+function matchSubGoal(target, subGoals, threshold) {
+    let bestIdx = -1;
+    let bestScore = 0;
+    for (let i = 0; i < subGoals.length; i++) {
+        const score = jaccardSimilarity(target, subGoals[i].description);
+        if (score > bestScore) {
+            bestScore = score;
+            bestIdx = i;
+        }
+    }
+    return bestScore >= threshold ? bestIdx : -1;
+}
+/**
+ * Manage the full sub-goal lifecycle across rounds.
+ *
+ * Accumulates sub-goals from all prior vault entries, processes the current
+ * round's declarations, derives status changes, and returns the complete
+ * structured SubGoal list.
+ *
+ * Status derivation priority (compiler-driven):
+ *   1. Agent declared done/canceled/blocked → explicit status change
+ *   2. next_action match → auto in_progress
+ *   3. success_criteria_met match → auto done
+ */
+function manageSubGoals(loopId, currentRound, lastRoundResult, vaultContext) {
+    const policy = getPolicy().evolution;
+    const allEntries = loopEntries(loopId, vaultContext);
+    const completedEntries = allEntries.filter((e) => entryRound(e) >= 1 && entryRound(e) < currentRound);
+    const subGoals = [];
+    // Phase 1 — Accumulate historical sub-goals from vault entries
+    for (const entry of completedEntries) {
+        const rnd = entryRound(entry);
+        const emerged = entryEmergedSubtasks(entry);
+        for (const desc of emerged) {
+            const id = deriveSubGoalId(desc);
+            // Dedup: skip if an existing sub-goal is too similar
+            if (matchSubGoal(desc, subGoals, policy.subgoal_dedup_threshold) >= 0)
+                continue;
+            subGoals.push(makeSubGoal({
+                id,
+                description: desc.trim(),
+                status: "pending",
+                declared_at_round: rnd,
+                status_changed_at_round: rnd,
+                priority: subGoals.length,
+            }));
+        }
+    }
+    // Phase 2 — Process current round's sub-task declarations
+    if (lastRoundResult) {
+        const rnd = lastRoundResult.round || (currentRound - 1);
+        // New sub-goals from this round
+        const emerged = lastRoundResult.emerged_subtasks ?? [];
+        for (const desc of emerged) {
+            if (matchSubGoal(desc, subGoals, policy.subgoal_dedup_threshold) >= 0)
+                continue;
+            subGoals.push(makeSubGoal({
+                id: deriveSubGoalId(desc),
+                description: desc.trim(),
+                status: "pending",
+                declared_at_round: rnd,
+                status_changed_at_round: rnd,
+                priority: subGoals.length,
+            }));
+        }
+        // Completed sub-goals
+        const completed = lastRoundResult.completed_subtasks ?? [];
+        for (const desc of completed) {
+            const idx = matchSubGoal(desc, subGoals, policy.subgoal_match_threshold);
+            if (idx >= 0 && subGoals[idx].status !== "done" && subGoals[idx].status !== "canceled") {
+                subGoals[idx].status = "done";
+                subGoals[idx].status_changed_at_round = rnd;
+                subGoals[idx].completed_at_round = rnd;
+            }
+        }
+        // Blocked sub-goals
+        const blocked = lastRoundResult.blocked_subtasks ?? [];
+        for (const desc of blocked) {
+            const idx = matchSubGoal(desc, subGoals, policy.subgoal_match_threshold);
+            if (idx >= 0 && subGoals[idx].status !== "done" && subGoals[idx].status !== "canceled") {
+                subGoals[idx].status = "blocked";
+                subGoals[idx].status_changed_at_round = rnd;
+            }
+        }
+        // Canceled sub-goals
+        const canceled = lastRoundResult.canceled_subtasks ?? [];
+        for (const desc of canceled) {
+            const idx = matchSubGoal(desc, subGoals, policy.subgoal_match_threshold);
+            if (idx >= 0 && subGoals[idx].status !== "done" && subGoals[idx].status !== "canceled") {
+                subGoals[idx].status = "canceled";
+                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;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Sort for display: in_progress first, then pending by age desc, then blocked, then done, then canceled
+    subGoals.sort((a, b) => {
+        const rank = (s) => {
+            switch (s.status) {
+                case "in_progress": return 0;
+                case "pending": return 1;
+                case "blocked": return 2;
+                case "done": return 3;
+                case "canceled": return 4;
+            }
+        };
+        const ra = rank(a), rb = rank(b);
+        if (ra !== rb)
+            return ra - rb;
+        // Within same status: pending by oldest first, done by most recent first
+        if (a.status === "pending")
+            return (currentRound - a.declared_at_round) - (currentRound - 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;
     });
+    return subGoals;
 }
-function tokens(text) {
-    return new Set(text.toLowerCase().match(/[a-z0-9\u4e00-\u9fff]+/g) ?? []);
+// ═══════════════════════════════════════════════════════════════════════════
+// Time-Aware Constraint Management (v2.3)
+// ═══════════════════════════════════════════════════════════════════════════
+/** Determine the source of a constraint by matching against known sources. */
+function constraintSource(text, objective, constraintsFromPlan) {
+    const norm = text.toLowerCase().trim();
+    if (objective.hard_constraints.some((c) => c.toLowerCase().trim() === norm))
+        return "hard";
+    if (constraintsFromPlan.some((c) => c.toLowerCase().trim() === norm))
+        return "plan";
+    if (objective.success_criteria.some((c) => c.toLowerCase().trim() === norm))
+        return "criteria";
+    return "discovered";
 }
-function similarity(left, right) {
-    const a = tokens(left);
-    const b = tokens(right);
-    if (a.size === 0 || b.size === 0)
-        return 1;
-    let intersection = 0;
-    for (const value of a)
-        if (b.has(value))
-            intersection++;
-    return intersection / new Set([...a, ...b]).size;
+/** Find the earliest round a constraint was discovered by scanning vault entries.
+ *  Uses similarity ≥ 0.5 for fuzzy matching. */
+function findDiscoveredRound(text, vaultEntries) {
+    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) {
+            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.
+ *  Uses similarity ≥ 0.5 for fuzzy matching. Returns 0 if never violated. */
+function findLastViolatedRound(text, vaultEntries) {
+    let latest = 0;
+    for (const entry of vaultEntries) {
+        const rnd = entryRound(entry);
+        if (rnd < 1)
+            continue;
+        const violations = Array.isArray(entry.constraint_violations)
+            ? entry.constraint_violations.filter((v) => typeof v === "string")
+            : [];
+        for (const v of violations) {
+            if (jaccardSimilarity(text, v) >= getPolicy().evolution.constraint_match_threshold) {
+                if (rnd > latest)
+                    latest = rnd;
+                break;
+            }
+        }
+    }
+    return latest;
+}
+/**
+ * Manage constraint lifecycle with time-aware decay.
+ *
+ * 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.
+ */
+function manageConstraintLifecycle(active, objective, constraintsFromPlan, vaultContext, currentRound) {
+    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);
+        // Structural constraints never decay
+        if (source === "hard" || source === "plan" || source === "criteria") {
+            metadata.push(makeConstraintMeta({
+                text,
+                discovered_at_round: objective.created_at_round || 1,
+                last_violated_at_round: findLastViolatedRound(text, completedEntries),
+                source,
+                status: "active",
+            }));
+            continue;
+        }
+        // Discovered constraints: check for inactivity
+        const discoveredAt = findDiscoveredRound(text, completedEntries);
+        const lastViolated = findLastViolatedRound(text, completedEntries);
+        const roundsSinceRelevant = lastViolated > 0
+            ? currentRound - lastViolated
+            : currentRound - (discoveredAt || currentRound);
+        const status = roundsSinceRelevant > policy.constraint_inactive_rounds
+            ? "inactive"
+            : "active";
+        metadata.push(makeConstraintMeta({
+            text,
+            discovered_at_round: discoveredAt || 0,
+            last_violated_at_round: lastViolated,
+            source: "discovered",
+            status,
+        }));
+    }
+    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 };
+}
+// jaccardSimilarity() imported from token-utils.ts
 export function alignTask(proposedTask, request, context) {
     const objective = request.loop_objective ?? latestObjective(request.loop_id, context);
     if (!objective)
         return makeTaskAlignment();
-    const score = similarity(proposedTask, [objective.objective, ...objective.success_criteria, ...objective.hard_constraints].join(" "));
+    const score = jaccardSimilarity(proposedTask, [objective.objective, ...objective.success_criteria, ...objective.hard_constraints].join(" "));
     return makeTaskAlignment({
         is_aligned: score >= 0.3,
         alignment_score: Number(score.toFixed(2)),
@@ -204,7 +643,7 @@ export function checkLoopHealth(loopId, request, context) {
     const alignment = alignTask(request.task, request, context);
     const violations = request.last_round_result?.constraint_violations.length ?? 0;
     const integrity = Math.max(0, 1 - violations * 0.2);
-    const continuity = previous ? similarity(previous.task, request.task) : 1;
+    const continuity = previous ? jaccardSimilarity(previous.task, request.task) : 1;
     const drift = alignment.alignment_score < 0.3 || continuity < 0.2;
     return makeLoopHealth({
         goal_alignment: alignment.alignment_score,
@@ -272,6 +711,9 @@ export function buildSelfEvalBlock(round) {
             },
             wrong_assumptions: [],
             next_action: "<next concrete action, or empty when complete>",
+            completed_subtasks: [],
+            blocked_subtasks: [],
+            canceled_subtasks: [],
         }, null, 2),
         "---end-loopforge-eval",
         "",
@@ -279,25 +721,17 @@ export function buildSelfEvalBlock(round) {
         "Set success=true only when the full goal and ALL hard constraints are verified.",
     ].join("\n");
 }
-function checkpoint(request, active, retired) {
-    const last = request.last_round_result;
-    if (!last?.compression_checkpoint)
-        return null;
-    const policy = getPolicy().checkpoint;
-    return makeCheckpointSummary({
-        label: last.checkpoint_label?.trim() || `Round ${last.round}`,
-        declared_at_round: last.round,
-        outcome: last.output_summary.slice(0, policy.outcome_max_chars),
-        carried_constraints: active.slice(0, policy.max_carried_constraints),
-        resolved_constraints: retired,
-    });
-}
+// v2.5: checkpoint() removed — agent_declared milestones from
+// compression_checkpoint supersede the separate CheckpointSummary.
+// See buildRollingSummary() signal 1.
 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 subGoals = manageSubGoals(request.loop_id, request.round, request.last_round_result, context);
     const alignment = alignTask(request.task, request, context);
     const health = checkLoopHealth(request.loop_id, { ...request, loop_objective: objective }, context);
     const warnings = unique([
@@ -306,13 +740,33 @@ export function compileLoop(request, context) {
             ? `Loop health recommends ${health.escalation_recommended}.`
             : "",
     ]);
+    // ── v2.5: Agent trust score ──────────────────────────────────────────
+    const flags = request.verification_flags ?? [];
+    const errors = flags.filter((f) => f.severity === "error").length;
+    const warns = flags.filter((f) => f.severity === "warn").length;
+    const trustScore = Math.max(0, Math.min(1, 1.0 - (errors * 0.15) - (warns * 0.03)));
+    // Trend — derive from vault entries (violation counts per round as proxy).
+    // 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 trend = [];
+    for (const entry of completedEntries.slice(-10)) {
+        const viols = Array.isArray(entry.constraint_violations)
+            ? entry.constraint_violations.filter((v) => typeof v === "string")
+            : [];
+        // 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)));
+    }
     const response = makeLoopCompileResponse({
         status: AgentStatus.OK,
         recompile_level: decision.level,
         diff_from_previous: decision.reasons.join(","),
         lineage: [`${request.loop_id}:r${request.round}`],
-        constraints_active: constraints.active,
+        constraints_active: constraintLifecycle.active,
         constraints_retired: constraints.retired,
+        constraints_inactive: constraintLifecycle.inactive,
+        constraint_metadata: constraintLifecycle.metadata,
         loop_id: request.loop_id,
         round: request.round,
         goal_id: deriveGoalId(request.loop_id, request.task, request.goal_id),
@@ -321,7 +775,9 @@ export function compileLoop(request, context) {
         loop_health: health,
         task_alignment: alignment,
         rolling_summary: rolling,
-        checkpoint_summary: checkpoint(request, constraints.active, constraints.retired),
+        sub_goals: subGoals,
+        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() ||
             request.last_round_result?.emerged_subtasks?.[0] || "",
         plan_source: request.plan_source,
@@ -331,6 +787,13 @@ export function compileLoop(request, context) {
     const statePath = `${policy.state_file.directory}/${request.loop_id}-state.md`;
     const state = createCanonicalLoopState(request, response, statePath);
     const markdown = renderCanonicalStateMarkdown(state);
+    // v2.4–v2.5: Adaptive L2 budget — scales with loop complexity
+    const adaptiveL2 = policy.prompt.l2_adaptive_enabled
+        ? Math.min(policy.prompt.l2_max_chars
+            + (request.round * policy.prompt.l2_adaptive_round_factor)
+            + ((rolling?.milestones?.length ?? 0) * policy.prompt.l2_adaptive_milestone_factor)
+            + (subGoals.length * policy.prompt.l2_adaptive_subgoal_factor), policy.prompt.l2_adaptive_max_chars)
+        : policy.prompt.l2_max_chars;
     const artifact = assemblePromptArtifact({
         state,
         level: decision.level,
@@ -339,7 +802,7 @@ export function compileLoop(request, context) {
         budgets: {
             l0: policy.prompt.l0_max_chars,
             l1: policy.prompt.l1_max_chars,
-            l2: policy.prompt.l2_max_chars,
+            l2: adaptiveL2,
         },
         attempt: request.attempt,
         selfEvaluationBlock: buildSelfEvalBlock(request.round),