loopforge 2.7.0 → 3.0.0

package/dist/loop-compiler.js

@@ -3,34 +3,38 @@
  * The compiler evolves structured state and renders one prompt artifact.
  * L0/L1/L2 control state density only; the external Agent owns reasoning.
  */
-import { createHash } from "node:crypto";
+import { deriveConstraintId, deriveCriterionId, deriveTextHash, } from "./derive-id.js";
 import { getPolicy } from "./policy.js";
-import { AgentStatus, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, makeSubGoal, makeTaskAlignment, } from "./protocol.js";
+import { AgentStatus, makeLoopCompileResponse, makeLoopCompileProjection, makeLoopHealth, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, makeTaskAlignment, } from "./protocol.js";
 import { createCanonicalLoopState, renderCanonicalStateMarkdown, } from "./canonical-state.js";
+import { auditEntries, deriveGate, deriveStructuredGate } from "./cognitive-governance.js";
+import { parseRoundReport, deriveCompilerProjection } from "./round-report.js";
 import { assemblePromptArtifact } from "./prompt-assembler.js";
 import { decidePromptLevel, } from "./prompt-policy.js";
 import { jaccardSimilarity, unique, entryRound } from "./token-utils.js";
-// unique() imported from token-utils.ts
+import { manageSubGoals as deriveSubGoals } from "./compiler-subgoals.js";
 function contextEntries(context) {
     if (!context || !Array.isArray(context.results))
         return [];
     return context.results.filter((value) => value !== null && typeof value === "object" && !Array.isArray(value));
 }
 function lineage(entry) {
-    const value = entry.loop_lineage ?? entry.lineage;
+    const value = entry.loop_lineage;
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
         : {};
 }
-// entryRound() imported from token-utils.ts
 function loopEntries(loopId, context) {
     return contextEntries(context)
         .filter((entry) => entry.loop_id === loopId || lineage(entry).loop_id === loopId)
         .sort((a, b) => entryRound(a) - entryRound(b));
 }
+function entryProjection(entry) {
+    const report = parseRoundReport(entry.round_report);
+    return report ? deriveCompilerProjection(report, entryRound(entry)) : null;
+}
 export function computeGoalTextHash(text) {
-    const normalized = text.trim().replace(/\s+/g, " ").toLowerCase();
-    return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+    return deriveTextHash(text, 12);
 }
 export function deriveGoalId(loopId, task, explicit = "") {
     return explicit.trim() || `${loopId}:${task.trim().toLowerCase()
@@ -57,9 +61,7 @@ export function getPreviousRound(loopId, round, context) {
         constraints_active: Array.isArray(data.constraints_active)
             ? data.constraints_active.filter((value) => typeof value === "string")
             : [],
-        output_summary: typeof entry.output_summary === "string"
-            ? entry.output_summary
-            : typeof data.output_summary === "string" ? data.output_summary : "",
+        output_summary: entryProjection(entry)?.summary ?? "",
     };
 }
 function latestObjective(loopId, context) {
@@ -96,17 +98,17 @@ function evolveObjective(request, context) {
             created_at_round: 1,
             loop_id: request.loop_id,
         });
-    const last = request.last_round_result;
+    const last = request.last_round_view;
     const history = [...(current.refinement_history ?? [])];
     let objective = current.objective || request.task;
     let version = current.version ?? 1;
-    if (last?.objective_refinement?.trim()) {
-        const refinement = last.objective_refinement.trim();
+    if (last?.objectiveRefinement?.trim()) {
+        const refinement = last.objectiveRefinement.trim();
         history.push(refinement);
         objective = `${objective}\nRefinement: ${refinement}`;
         version++;
     }
-    const revisions = new Map((last?.revised_success_criteria ?? []).map((item) => [item.old, item.new]));
+    const revisions = new Map((last?.criterionRevisions ?? []).map((item) => [item.old, item.new]));
     return makeLoopObjective({
         ...current,
         objective,
@@ -118,9 +120,9 @@ function evolveObjective(request, context) {
     });
 }
 function evolveConstraints(request, objective, previous) {
-    const retired = unique(request.last_round_result?.retracted_constraints ?? []);
+    const retired = unique(request.last_round_view?.constraintEvents?.retired ?? []);
     const retiredSet = new Set(retired);
-    const discovered = unique(request.last_round_result?.discovered_constraints ?? [])
+    const discovered = unique(request.last_round_view?.discoveries?.newConstraints ?? [])
         .slice(0, getPolicy().evolution.max_discovered_constraints_per_round);
     const active = unique([
         ...(previous?.constraints_active ?? []),
@@ -135,31 +137,73 @@ function evolveConstraints(request, objective, previous) {
 // ═══════════════════════════════════════════════════════════════════════════
 // 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") : [];
+    return entryProjection(entry)?.evidence?.verifiedClaims ?? [];
+}
+function verifiedClaims(loopId, context) {
+    const facts = new Set();
+    const refs = new Set();
+    for (const entry of loopEntries(loopId, context)) {
+        const report = entry.round_report;
+        if (!report || typeof report !== "object" || Array.isArray(report))
+            continue;
+        const evidence = report.evidence;
+        if (!evidence || typeof evidence !== "object" || Array.isArray(evidence))
+            continue;
+        const envelope = evidence;
+        const provenance = envelope.provenance;
+        if (!provenance || typeof provenance !== "object" || Array.isArray(provenance))
+            continue;
+        const provenanceMap = provenance;
+        if (!Array.isArray(envelope.claims))
+            continue;
+        for (const raw of envelope.claims) {
+            if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                continue;
+            const claim = raw;
+            if (typeof claim.targetId !== "string" || !Array.isArray(claim.evidenceRefs))
+                continue;
+            const verifiedRefs = claim.evidenceRefs.filter((ref) => {
+                if (typeof ref !== "string")
+                    return false;
+                const value = provenanceMap[ref];
+                return Boolean(value && typeof value === "object" && !Array.isArray(value) &&
+                    value.status === "verified" &&
+                    value.source !== "agent");
+            });
+            if (verifiedRefs.length === 0)
+                continue;
+            facts.add(claim.targetId);
+            for (const ref of verifiedRefs)
+                refs.add(ref);
+        }
+    }
+    return { facts: [...facts].sort(), refs: [...refs].sort() };
+}
+/** 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) {
+    const aIsId = isCriterionId(a);
+    const bIsId = isCriterionId(b);
+    // Both are IDs — exact string comparison
+    if (aIsId && bIsId)
+        return a === b;
+    // One is an ID — derive ID from the other and compare
+    if (aIsId)
+        return a === deriveCriterionId(b);
+    if (bIsId)
+        return deriveCriterionId(a) === b;
+    // Neither is an ID — Jaccard fallback
+    return jaccardSimilarity(a, b) >= getPolicy().evolution.criteria_dedup_threshold;
+}
+function isCriterionId(ref) {
+    return /^cr-[a-f0-9]{8}$/.test(ref);
 }
 /** 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.
+ *  success_criteria_met against the previous entry's.
+ *  v2.11: ID-first matching (cr-XXXXXXXX) with Jaccard similarity
+ *  fallback for backward compatibility.
  *  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) {
@@ -173,7 +217,7 @@ function detectNewCriteria(current, previous) {
     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));
+    return currMet.filter((curr) => prevMet.every((prev) => !criteriaMatch(curr, prev)));
 }
 /** Read constraints_active from an entry's lineage. */
 function entryActiveConstraints(entry) {
@@ -183,29 +227,15 @@ function entryActiveConstraints(entry) {
 }
 /** 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 [];
+    return entryProjection(entry)?.constraintEvents?.retired ?? [];
 }
-/** 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;
+    return entryProjection(entry)?.evidence?.progressRatio ?? 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 outcomeRaw = last ? entryProjection(last)?.summary ?? "" : "";
     const outcomeMax = getPolicy().checkpoint.outcome_max_chars;
     const outcome = outcomeRaw.length > outcomeMax
         ? outcomeRaw.slice(0, outcomeMax) + "…"
@@ -240,28 +270,48 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
         const data = lineage(entry);
         const round = entryRound(entry);
         const success = entry.success ?? data.success;
-        const summary = typeof entry.output_summary === "string"
-            ? entry.output_summary
-            : typeof data.output_summary === "string" ? data.output_summary : "";
+        const summary = entryProjection(entry)?.summary ?? "";
         if (summary)
             outcomes.push(`[R${round}] ${success === false ? "failed" : "accepted"}: ${summary}`);
-        const violations = Array.isArray(entry.constraint_violations)
-            ? entry.constraint_violations
-            : Array.isArray(data.constraint_violations) ? data.constraint_violations : [];
+        const violations = entryProjection(entry)?.violations ?? [];
         issues.push(...violations.filter((item) => typeof item === "string"));
     }
+    const issueCounts = new Map();
+    for (const issue of issues) {
+        const key = issue.trim().replace(/\s+/g, " ").toLowerCase();
+        if (!key)
+            continue;
+        const previous = issueCounts.get(key);
+        issueCounts.set(key, { text: previous?.text ?? issue.trim(), count: (previous?.count ?? 0) + 1 });
+    }
     // ── 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 failedGroups = [];
+    for (const entry of completedEntries) {
+        const data = lineage(entry);
+        if ((entry.success ?? data.success) !== false)
+            continue;
+        const text = (entryProjection(entry)?.summary ?? "").trim();
+        if (!text)
+            continue;
+        const group = failedGroups.find((candidate) => jaccardSimilarity(candidate.text, text) >= getPolicy().evolution.failed_pattern_match_threshold);
+        if (group)
+            group.count++;
+        else
+            failedGroups.push({ text, count: 1 });
+    }
     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);
+        const report = parseRoundReport(entry.round_report);
         // Signal 1: Agent-declared checkpoint
-        const isAgentCheckpoint = lin.compression_checkpoint === true;
+        const isAgentCheckpoint = Boolean(report?.phaseBoundaryProposal) ||
+            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);
@@ -275,9 +325,10 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
                 ? "agent_declared"
                 : "criteria_milestone";
             const label = isAgentCheckpoint
-                ? (typeof lin.checkpoint_label === "string" && lin.checkpoint_label.trim()
-                    ? lin.checkpoint_label.trim()
-                    : `Round ${rnd}`)
+                ? (report?.phaseBoundaryProposal?.label?.trim() ||
+                    (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;
@@ -320,205 +371,20 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
         return null;
     return makeRollingSummary({
         key_outcomes: unique(outcomes),
-        recurring_issues: unique(issues),
+        recurring_issues: [...issueCounts.values()]
+            .filter((issue) => issue.count >= 2)
+            .map((issue) => `${issue.text} (${issue.count} rounds)`),
         rounds_sampled: windowEntries.length,
         generated_at_round: currentRound,
-        failed_patterns: [],
+        failed_patterns: failedGroups
+            .filter((failure) => failure.count >= 2)
+            .map((failure) => `${failure.text} (${failure.count} attempts)`),
         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;
-}
-// ═══════════════════════════════════════════════════════════════════════════
+// Sub-goal lifecycle is implemented in compiler-subgoals.ts; this facade keeps
+// the compiler's public entry point and projection flow unchanged.
 // Time-Aware Constraint Management (v2.3)
 // ═══════════════════════════════════════════════════════════════════════════
 /** Determine the source of a constraint by matching against known sources. */
@@ -533,17 +399,25 @@ function constraintSource(text, objective, constraintsFromPlan) {
     return "discovered";
 }
 /** Find the earliest round a constraint was discovered by scanning vault entries.
- *  Uses similarity ≥ 0.5 for fuzzy matching. */
+ *  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")
-            : [];
+        const discovered = entryProjection(entry)?.discoveries?.newConstraints ?? [];
         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;
@@ -554,17 +428,25 @@ function findDiscoveredRound(text, vaultEntries) {
     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. */
+ *  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) {
+    const targetId = deriveConstraintId(text);
     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")
-            : [];
+        const violations = entryProjection(entry)?.violations ?? [];
         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 (rnd > latest)
                     latest = rnd;
@@ -592,6 +474,7 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
         // 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),
@@ -610,6 +493,7 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
             ? "inactive"
             : "active";
         metadata.push(makeConstraintMeta({
+            id: deriveConstraintId(text),
             text,
             discovered_at_round: discoveredAt || 0,
             last_violated_at_round: lastViolated,
@@ -625,7 +509,6 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
         .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)
@@ -641,7 +524,7 @@ export function alignTask(proposedTask, request, context) {
 export function checkLoopHealth(loopId, request, context) {
     const previous = getPreviousRound(loopId, request.round - 1, context);
     const alignment = alignTask(request.task, request, context);
-    const violations = request.last_round_result?.constraint_violations.length ?? 0;
+    const violations = request.last_round_view?.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;
@@ -656,70 +539,133 @@ export function checkLoopHealth(loopId, request, context) {
 }
 function levelDecision(request, context) {
     const previous = getPreviousRound(request.loop_id, request.round - 1, context);
-    const last = request.last_round_result;
+    const last = request.last_round_view;
     const hasNewInformation = Boolean(request.new_since_last_round.trim() ||
-        last?.discovered_constraints?.length ||
-        last?.objective_refinement?.trim() ||
-        last?.emerged_subtasks?.length ||
-        last?.retracted_constraints?.length ||
-        last?.revised_success_criteria?.length ||
-        last?.wrong_assumptions?.length);
+        last?.discoveries?.newConstraints?.length ||
+        last?.objectiveRefinement?.trim() ||
+        last?.discoveries?.emergedWork?.length ||
+        last?.constraintEvents?.retired?.length ||
+        last?.criterionRevisions?.length ||
+        last?.discoveries?.wrongAssumptions?.length ||
+        last?.evidence?.verifiedClaims.length);
     const lastFullRound = loopEntries(request.loop_id, context)
         .filter((entry) => lineage(entry).recompile_level === "l2")
         .map(entryRound)
         .filter((round) => round < request.round)
         .at(-1) ?? 1;
+    const entries = loopEntries(request.loop_id, context)
+        .filter((entry) => entryRound(entry) < request.round);
+    const lastMeaningfulRound = [...entries].reverse().find((entry) => {
+        const data = lineage(entry);
+        const evidence = entryProjection(entry)?.evidence;
+        return Boolean(entryCriteriaMet(entry).length ||
+            evidence?.observedFiles.length ||
+            entryProjection(entry)?.discoveries?.newConstraints.length ||
+            entryProjection(entry)?.discoveries?.emergedWork.length);
+    });
+    const meaningfulSections = 2 + [
+        request.task.trim(),
+        ...(last?.violations ?? []),
+        ...(last?.evidence?.criteriaRemaining ?? []),
+        ...(last?.evidence?.criteriaMet ?? []),
+        ...(last?.discoveries?.newConstraints ?? []),
+        ...(last?.discoveries?.emergedWork ?? []),
+        ...(last?.evidence?.observedFiles ?? []),
+    ].filter(Boolean).length;
+    const promptPolicy = getPolicy().prompt;
     return decidePromptLevel({
         round: request.round,
         attempt: request.attempt,
         forceLevel: request.force_level,
         hasPlanSource: Boolean(request.plan_source),
-        checkpointBoundary: last?.compression_checkpoint === true,
-        goalChanged: previous !== null && previous.goal_id !== deriveGoalId(request.loop_id, request.task, request.goal_id),
+        checkpointBoundary: Boolean(last?.phaseBoundaryProposal),
+        goalChanged: Boolean(last?.objectiveRefinement?.trim()) ||
+            (previous !== null && previous.goal_id !== deriveGoalId(request.loop_id, request.task, request.goal_id)),
+        constraintChanged: Boolean(last?.discoveries?.newConstraints?.length || last?.constraintEvents?.retired?.length),
         previousStateMissing: request.round > 1 && previous === null,
-        previousFailedWithoutNewInformation: last?.success === false && !hasNewInformation,
+        previousFailedWithoutNewInformation: last?.outcome === "failed" && !hasNewInformation,
         verificationContradicted: (request.verification_flags ?? [])
             .some((flag) => flag.severity === "error"),
         consecutiveRejections: request.consecutive_rejections,
         fullRefreshInterval: getPolicy().prompt.full_refresh_interval,
         lastFullRound,
+        l1Streak: Math.max(0, request.round - lastFullRound - 1),
+        maxL1Streak: promptPolicy.adaptive_refresh ? promptPolicy.max_l1_streak : undefined,
+        meaningfulSections: request.round <= 2
+            ? Math.max(meaningfulSections, promptPolicy.min_meaningful_sections)
+            : meaningfulSections,
+        minMeaningfulSections: promptPolicy.adaptive_refresh
+            ? promptPolicy.min_meaningful_sections
+            : undefined,
+        staleProgressRounds: request.round - (lastMeaningfulRound ? entryRound(lastMeaningfulRound) : 1),
+        staleRoundThreshold: promptPolicy.adaptive_refresh
+            ? promptPolicy.stale_round_threshold
+            : undefined,
     });
 }
 export function decideLevel(request, context) {
     return levelDecision(request, context).level;
 }
-export function buildSelfEvalBlock(round) {
-    return [
+export function buildRoundReportBlock(round, prevDriftFlags) {
+    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 report = {
+        format: "loopforge.round-report",
+        outcome: "partial",
+        continuation: "continue",
+        summary: `<verified result of round ${round}>`,
+        violations: [],
+        evidence: {
+            files: [],
+            checks: [{ name: "<configured provider or command name>", status: "not_run" }],
+            claims: [{
+                    id: "claim-<12 hex chars>",
+                    targetId: "<cr-XXXXXXXX or criterion text>",
+                    evidenceRefs: ["provider:<name>"],
+                }],
+            noChangeReason: "",
+        },
+        discoveries: {
+            wrongAssumptions: [],
+            emergedWork: [],
+            facts: [],
+            newConstraints: [],
+        },
+        subGoalEvents: { completed: [], blocked: [], canceled: [] },
+    };
+    // v2.8: Inject drift clarification field when previous round had drift flags
+    if (needsClarification) {
+        const flagTypes = [
+            hasIntentDrift ? "intent_drift" : "",
+            hasSubGoalDrift ? "subgoal_drift" : "",
+        ].filter(Boolean).join(" / ");
+        report.discoveries = {
+            ...report.discoveries,
+            facts: [`Explain the evidence-backed pivot from ${flagTypes}`],
+        };
+        report.driftClarification = {
+            explanation: "<explain why the current evidence requires this pivot>",
+            anchors: ["<criterion ID, constraint ID, or observed file path>"],
+        };
+    }
+    const lines = [
         "### LoopForge Evaluation (Required)",
         "",
         `After completing Round ${round}, replace the placeholder values below`,
         "with your actual results and submit via `loopforge_next`.",
-        "---loopforge-eval",
-        JSON.stringify({
-            success: false,
-            output_summary: `<verified result of round ${round}>`,
-            constraint_violations: [],
-            should_continue: true,
-            discovered_constraints: [],
-            emerged_subtasks: [],
-            execution_evidence: {
-                files_changed: [],
-                test_results: { passed: 0, failed: 0, skipped: 0 },
-                success_criteria_met: [],
-                success_criteria_remaining: [],
-                progress_estimate: 0,
-            },
-            wrong_assumptions: [],
-            next_action: "<next concrete action, or empty when complete>",
-            completed_subtasks: [],
-            blocked_subtasks: [],
-            canceled_subtasks: [],
-        }, null, 2),
-        "---end-loopforge-eval",
-        "",
-        "IMPORTANT: Replace every <placeholder> with your actual data.",
-        "Set success=true only when the full goal and ALL hard constraints are verified.",
-    ].join("\n");
+    ];
+    if (needsClarification) {
+        lines.push("", "> ⚠️ **Drift Detected:** The verification gate detected that your previous", "> round's previously suggested action did not match your actual output.", "> Explain the evidence-backed pivot in `driftClarification` below and include a runtime-verifiable anchor.", "> An honest explanation helps the enforcement gate distinguish intentional", "> course corrections from unacknowledged drift.");
+    }
+    lines.push("Submit this object in the `report` parameter:");
+    lines.push(JSON.stringify(report, null, 2));
+    lines.push("");
+    lines.push("IMPORTANT: Replace every <placeholder> with your actual data.");
+    lines.push("Set outcome=success only when every criterion has runtime-verifiable evidence; set continuation=stop only when no further round is requested.");
+    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.");
+    return lines.join("\n");
 }
 // v2.5: checkpoint() removed — agent_declared milestones from
 // compression_checkpoint supersede the separate CheckpointSummary.
@@ -731,7 +677,7 @@ export function compileLoop(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 subGoals = deriveSubGoals(request.loop_id, request.round, request.last_round_view, context, entryProjection);
     const alignment = alignTask(request.task, request, context);
     const health = checkLoopHealth(request.loop_id, { ...request, loop_objective: objective }, context);
     const warnings = unique([
@@ -751,13 +697,35 @@ export function compileLoop(request, 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")
-            : [];
+        const viols = entryProjection(entry)?.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)));
     }
+    const verified = verifiedClaims(request.loop_id, context);
+    const latestReport = [...loopEntries(request.loop_id, context)].reverse()
+        .map((entry) => parseRoundReport(entry.round_report))
+        .find((report) => report !== null);
+    const audit = auditEntries(request.loop_id, loopEntries(request.loop_id, context));
+    const regressionObligations = audit.regressionObligations.map((obligation) => ({
+        id: obligation.id,
+        description: `Re-run ${obligation.check}`,
+        sourceRound: obligation.sourceRound,
+        evidenceRefs: [`check:${obligation.check}`],
+        status: obligation.status,
+    }));
+    const latestBlocker = latestReport?.outcome === "blocked" && latestReport.blocker;
+    const blockerGate = latestBlocker
+        ? latestBlocker.action
+            ? deriveStructuredGate(latestBlocker.action)
+            : deriveGate(latestBlocker.reason, latestBlocker.references)
+        : null;
+    const activeBlockers = latestBlocker && blockerGate?.gate.kind === "user" &&
+        !audit.unresolvedUserGates.includes(blockerGate.id)
+        ? []
+        : latestBlocker
+            ? [latestBlocker.reason]
+            : [];
     const response = makeLoopCompileResponse({
         status: AgentStatus.OK,
         recompile_level: decision.level,
@@ -778,8 +746,18 @@ export function compileLoop(request, context) {
         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] || "",
+        // Agent intent is advisory only. Runtime suggestions are derived from
+        // remaining criteria, active sub-goals and blockers; never copy intent
+        // into the canonical next-action projection.
+        projection: makeLoopCompileProjection({
+            suggestedNextAction: request.last_round_view?.evidence?.criteriaRemaining?.[0] ||
+                request.last_round_view?.discoveries?.emergedWork?.[0] || "",
+            verifiedFacts: verified.facts,
+            verifiedEvidenceRefs: verified.refs,
+            regressionObligations,
+            discoveredFacts: latestReport?.discoveries?.facts ?? [],
+            activeBlockers,
+        }),
         plan_source: request.plan_source,
         warnings,
     });
@@ -794,6 +772,10 @@ export function compileLoop(request, context) {
             + ((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;
+    // v2.8: L2 pointer mode — when enabled, skip the monolithic markdown blob.
+    // Structured L2 sections (milestones, sub-goals, trust, progress) still
+    // render. The state file on disk is the durable source of truth.
+    const l2Pointer = policy.prompt.l2_pointer_enabled && decision.level === "l2";
     const artifact = assemblePromptArtifact({
         state,
         level: decision.level,
@@ -805,12 +787,36 @@ export function compileLoop(request, context) {
             l2: adaptiveL2,
         },
         attempt: request.attempt,
-        selfEvaluationBlock: buildSelfEvalBlock(request.round),
-        fullStateMarkdown: markdown,
+        roundReportBlock: buildRoundReportBlock(request.round, request.verification_flags),
+        fullStateMarkdown: l2Pointer ? undefined : markdown,
+        agentIntent: request.last_round_view?.agentIntent,
+        promptRequests: request.last_round_view?.contextRequest ?? undefined,
+    });
+    const priorEntries = loopEntries(request.loop_id, context)
+        .filter((entry) => entryRound(entry) < request.round);
+    const previousL2 = [...priorEntries].reverse()
+        .find((entry) => lineage(entry).recompile_level === "l2");
+    artifact.lastL2Round = artifact.level === "l2"
+        ? request.round
+        : previousL2 ? entryRound(previousL2) : 0;
+    const meaningfulEntry = [...priorEntries].reverse().find((entry) => {
+        const data = lineage(entry);
+        const evidence = entryProjection(entry)?.evidence;
+        return Boolean(entryCriteriaMet(entry).length ||
+            evidence?.observedFiles.length ||
+            entryProjection(entry)?.discoveries?.newConstraints.length ||
+            entryProjection(entry)?.discoveries?.emergedWork.length);
     });
+    artifact.lastMeaningfulProgressRound = meaningfulEntry
+        ? entryRound(meaningfulEntry)
+        : request.round <= 1 ? 0 : 1;
+    artifact.stateAgeRounds = artifact.lastMeaningfulProgressRound > 0
+        ? Math.max(0, request.round - artifact.lastMeaningfulProgressRound)
+        : request.round - 1;
     response.prompt = artifact.renderedPrompt;
     response.prompt_artifact = artifact;
     response.state_file_content = policy.state_file.enabled ? markdown : undefined;
+    response.canonical_state = state;
     return response;
 }
 //# sourceMappingURL=loop-compiler.js.map