loopforge 3.7.1 → 3.8.2

package/dist/loop-compiler.js

@@ -5,13 +5,16 @@
  */
 import { createHash } from "node:crypto";
 import { getPolicy } from "./policy.js";
-import { AgentStatus, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, makeSubGoal, makeTaskAlignment, } from "./protocol.js";
+import { AgentStatus, makeLoopCompileResponse, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, } from "./protocol.js";
 import { createCanonicalLoopState, renderCanonicalStateMarkdown, } from "./canonical-state.js";
-import { decodeRound, entryLineage, entryCriteriaMet, entryCriteriaRemaining, entryActiveConstraints, entryRetractedConstraints, entryProgressEstimate, entryEmergedSubtasks, entrySubGoalUpdates, machineGitMotionSeries, mergedRoundsFromEntries, } from "./committed-round.js";
-import { contractRoundEvaluations, deriveActiveRoundContract, } from "./round-contract.js";
+import { decodeBacktrackRecord, decodeRound, entryLineage, entryCriteriaMet, entryCriteriaRemaining, entryActiveConstraints, entryRetractedConstraints, entryProgressEstimate, machineGitMotionSeries, derivationRounds, } from "./committed-round.js";
+import { NO_IN_FLIGHT_ROUND, deriveRoundFacts } from "./round-facts.js";
+import { recoveryBriefLines } from "./enforcement-gate.js";
+import { deriveSubGoals, duplicateEmergedDeclarations } from "./subgoal-state.js";
+import { claimedMetCriteria, claimedRemainingCriteria } from "./self-eval.js";
 import { assemblePromptArtifact } from "./prompt-assembler.js";
 import { decidePromptLevel, } from "./prompt-policy.js";
-import { deriveItemId, jaccardSimilarity, unique, entryRound } from "./token-utils.js";
+import { deriveCriterionId, deriveItemId, isCriterionId, normalizeText, unique, entryRound, } from "./token-utils.js";
 function contextEntries(context) {
     if (!context || !Array.isArray(context.results))
         return [];
@@ -55,32 +58,6 @@ 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 lacks the three presented_* fields (as on L0/L2 compiles),
- *  so callers render the full L1 state. */
-export function readPresentedBaseline(loopId, round, context) {
-    const entry = roundCanonicalEntry(loopEntries(loopId, context), round - 1);
-    if (!entry)
-        return null;
-    const data = entryLineage(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 = roundCanonicalEntry(loopEntries(loopId, context), round);
     if (!entry)
@@ -216,86 +193,50 @@ function evolveConstraints(request, objective, previous, context) {
 // ═══════════════════════════════════════════════════════════════════════════
 // Hierarchical Summary (v2.1)
 // ═══════════════════════════════════════════════════════════════════════════
-/** 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 view = decodeRound(entry);
-        const viols = view
-            ? view.constraintViolations ?? []
-            : Array.isArray(entry.constraint_violations)
-                ? entry.constraint_violations.filter((v) => typeof v === "string")
-                : [];
-        for (const text of viols) {
-            const list = violations.get(text) ?? [];
-            list.push(rnd);
-            violations.set(text, list);
-        }
-        const flags = view
-            ? view.verificationFlags
-            : 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 });
+/** v3.8.1: THE recurring-fact derivation — one walk over the committed
+ *  history, grouping repeated machine facts by what they are ABOUT.
+ *
+ *  This replaces three separate answers to "what keeps going wrong":
+ *  `deriveLessons` (whole history, count >= 2, keyed by constraint text or
+ *  check id), `rolling_summary.recurring_issues` (the last 5 rounds' raw
+ *  violation texts, with NO threshold at all despite the name), and the L1/L2
+ *  sections built on top of each. Three windows over one fact set is exactly
+ *  the parallel semantics this release removes.
+ *
+ *  Callers FILTER this list rather than re-deriving: the state file renders
+ *  the genuinely recurring set (count >= 2), the prompt renders the recent
+ *  tail as Active Warnings.
+ *
+ *  Presentation only: the result never feeds enforcement. */
+export function deriveRecurringFlags(committedRounds) {
+    const byKey = new Map();
+    const record = (kind, subject, ref, round) => {
+        const key = `${kind}${subject}${ref}`;
+        const existing = byKey.get(key);
+        if (existing) {
+            existing.count++;
+            if (!existing.rounds.includes(round))
+                existing.rounds.push(round);
+            return;
         }
-    }
-    for (const [text, rounds] of errors) {
-        if (rounds.length >= 2) {
-            lessons.push({ text, kind: "verification_error", count: rounds.length, rounds });
+        byKey.set(key, { subject, kind, ref, count: 1, rounds: [round] });
+    };
+    for (const round of committedRounds) {
+        for (const text of round.constraintViolations ?? []) {
+            record("constraint_violation", text, "", round.round);
         }
-    }
-    for (const [text, rounds] of warns) {
-        if (rounds.length >= 2) {
-            lessons.push({ text, kind: "verification_warning", count: rounds.length, rounds });
+        for (const flag of round.verificationFlags) {
+            const kind = flag.severity === "error"
+                ? "verification_error"
+                : flag.severity === "warn" ? "verification_warning" : null;
+            if (!kind)
+                continue;
+            record(kind, flag.check, flag.ref ?? "", round.round);
         }
     }
-    return lessons.sort((a, b) => b.count - a.count);
-}
-/** v3.3: Derive display-only round statistics over the last `window`
- *  committed rounds — files changed, rejected attempts (snapshot.attempt
- *  minus one: the successful commit's attempt counts the redo), and the
- *  self-reported progress delta vs the previous round. One row per round,
- *  preferring the :feedback entry when both lineage and feedback entries
- *  exist. Zero persistence — re-derived from committed entries. */
-function deriveRoundStats(rounds, window = 5) {
-    const stats = [];
-    let prevProgress = null;
-    for (const round of rounds.slice(-window)) {
-        const ev = round.executionEvidence;
-        const files = ev?.files_changed;
-        const rawProgress = ev?.progress_estimate;
-        const progress = typeof rawProgress === "number" ? rawProgress : null;
-        stats.push({
-            round: round.round,
-            filesChangedCount: Array.isArray(files) ? files.length : null,
-            rejectedAttempts: round.attempt >= 1 ? round.attempt - 1 : null,
-            progressDelta: progress !== null && prevProgress !== null
-                ? Number((progress - prevProgress).toFixed(3))
-                : null,
-        });
-        if (progress !== null)
-            prevProgress = progress;
-    }
-    return stats;
+    return [...byKey.values()].sort((a, b) => b.count - a.count ||
+        a.subject.localeCompare(b.subject) ||
+        a.ref.localeCompare(b.ref));
 }
 /** v3.3: Machine git-motion cross-check over the last 3 committed rounds
  *  (the R4 window). Undefined when no committed rounds carry git snapshots
@@ -308,39 +249,36 @@ function deriveMachineStatus(rounds, currentRound) {
     const motionRounds = series.filter(Boolean).length;
     return { windowRounds: 3, gitMotion: motionRounds > 0, motionRounds };
 }
-/** v3.4: ACTIVE Round Contract for the compile round — derived from the
- *  committed evals of earlier rounds only, never from request data. Reads
- *  the hydrated merged lineage entries (one per round; a committed decision
- *  is merged onto the round's lineage entry with `committed_action` set),
- *  skipping rounds whose committed action was "backtrack" (a roll-back
- *  directive, not an executed round). Because it runs identically on every
- *  compile path — including rejection retries and resume / unpause /
- *  backtrack compiles that carry no last_round_result — a contract round's
- *  re-compiles keep showing its contract as the Current Task. Null when no
- *  active contract: the Current Task falls back to the original task text. */
-function deriveActiveContract(loopId, context, currentRound) {
-    const entries = loopEntries(loopId, context);
-    const canonical = Array.from({ length: Math.max(0, currentRound - 1) }, (_, index) => roundCanonicalEntry(entries, index + 1)).filter((entry) => entry !== null);
-    return deriveActiveRoundContract(contractRoundEvaluations(mergedRoundsFromEntries(canonical, currentRound)));
-}
 /** v3.2: Derive per-criterion status — the "goal → criteria → evidence"
  *  vertical view. Each objective criterion gets: met/remaining/unknown
- *  (from per-round success_criteria_met/remaining reports, ID-first
- *  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) {
+ *  (from per-round criterion_claims, ID-first or normalized-exact matching),
+ *  the round it was first reported met, and the sub-goals a contract item
+ *  referencing it also names (explicit `subgoal_refs`, never a text guess).
+ *  Zero persistence — re-derived from the vault every compile. */
+export function deriveCriterionStatuses(loopId, context, objective, currentRound, lastRoundResult,
+/** v3.8.1: the criterion machine facts from the shared bundle. A criterion
+ *  is `verified` / `contradicted` / `insufficient` only through an item that
+ *  references it — a claim alone can never reach `verified` — and the fact
+ *  is derived over the WHOLE committed history, so it survives its contract
+ *  closing (see `deriveCriterionFacts`). */
+criterionFacts = []) {
     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 lastEv = lastRoundResult?.execution_report;
+    const lastMet = claimedMetCriteria(lastEv);
+    const lastRemaining = claimedRemainingCriteria(lastEv);
     const lastEntry = entries[entries.length - 1] ?? null;
     const lastEntryRemaining = lastEntry ? entryCriteriaRemaining(lastEntry) : [];
-    const matchThreshold = getPolicy().evolution.subgoal_match_threshold;
+    // v3.8.1: criterion → machine status + explicit sub-goal links, from the
+    // shared `RoundFacts` bundle (whole committed history). It used to be
+    // re-derived here from the ACTIVE contract, which made both maps empty the
+    // moment the contract closed — the criterion's machine fact, and the
+    // sub-goal links carried on the same item, disappeared while the sub-goal
+    // side of the very same fact survived. One derivation, one window.
+    const factsByCriterion = new Map(criterionFacts.map((fact) => [fact.criterion_id, fact]));
     return objective.success_criteria.map((text) => {
         let metAtRound = null;
         for (const entry of entries) {
@@ -353,28 +291,33 @@ export function deriveCriterionStatuses(loopId, context, objective, currentRound
         if (metAtRound === null && lastMet.some((met) => criteriaMatch(met, text))) {
             metAtRound = currentRound - 1;
         }
-        const status = metAtRound !== null
-            ? "met"
+        // v3.8: a claim reaches `claimed` at most. Only a machine fact about a
+        // contract item that references this criterion can go further.
+        const claimedStatus = metAtRound !== null
+            ? "claimed"
             : lastRemaining.some((remaining) => criteriaMatch(remaining, text)) ||
                 lastEntryRemaining.some((remaining) => criteriaMatch(remaining, text))
                 ? "remaining"
                 : "unknown";
+        const fact = factsByCriterion.get(deriveCriterionId(text));
+        const status = fact?.status ?? claimedStatus;
         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),
+            // v3.8.1: explicit refs only — empty when no contract item links this
+            // criterion to a sub-goal.
+            related_subgoal_ids: fact?.related_subgoal_ids ?? [],
         };
     });
 }
-/** 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.
- *  v3.3: exported for the verification gate's windowed criteria-completion
- *  scan (R4/R5 exculpatory cross-check). */
+/** v3.8: Rank item statuses so the strongest machine fact wins when several
+ *  items reference the same criterion. */
+/** Match two criterion references. If either is a criterion id
+ *  (cr-XXXXXXXX), compares ids; otherwise requires the two texts to be
+ *  EXACTLY equal after normalization (v3.8.1 — the similarity fallback is
+ *  gone, so a paraphrase is a different criterion). */
 export function criteriaMatch(a, b) {
     const aIsId = isCriterionId(a);
     const bIsId = isCriterionId(b);
@@ -386,13 +329,16 @@ export function criteriaMatch(a, b) {
         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;
+    // v3.8.1: normalized text must be EXACTLY equal. The former Jaccard
+    // fallback let two merely-similar criterion strings count as the same
+    // criterion, which could fuse distinct criteria (and suppress or invent a
+    // criteria milestone) on a similarity score rather than on an identity.
+    return normalizeText(a) === normalizeText(b);
 }
 /** Detect newly met criteria by comparing the current entry's
- *  success_criteria_met against the previous entry's.
- *  v2.11: ID-first matching (cr-XXXXXXXX) with Jaccard similarity
- *  fallback for natural-language references.
+ *  met criterion_claims against the previous entry's.
+ *  v2.11/v3.8.1: id-first (cr-XXXXXXXX), then normalized-exact text —
+ *  no similarity.
  *  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) {
@@ -433,56 +379,14 @@ function buildMilestoneFromEntries(phaseEntries, startRound, endRound, label, ki
         generated_at_round: endRound,
     });
 }
-/** 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) {
+/** v3.8.1: the milestone history bound. Applied identically at every prompt
+ *  level and in the state file, so the milestone set is a function of
+ *  committed facts rather than of which level happened to compile. (The
+ *  v3.0.1 sampler chose which milestones to keep from an UNBOUNDED list and
+ *  did nothing at L2 — so the state file’s phase history depended on the
+ *  prompt level and had no bound of its own.) */
+const MILESTONE_HISTORY_CAP = 50;
+export function buildRollingSummary(loopId, currentRound, context, sinceRound = 0) {
     const policy = getPolicy().summary;
     const allEntries = loopEntries(loopId, context);
     // ── Phase 1: Recent Window (preserves existing behavior) ──
@@ -493,7 +397,6 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
     })
         .slice(-policy.window);
     const outcomes = [];
-    const issues = [];
     for (const entry of windowEntries) {
         const view = decodeRound(entry);
         const data = entryLineage(entry);
@@ -513,12 +416,6 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
             : success === false ? "failed" : "accepted";
         if (summary)
             outcomes.push(`[R${round}] ${outcomeLabel}: ${summary}`);
-        const violations = view
-            ? view.constraintViolations ?? []
-            : Array.isArray(entry.constraint_violations)
-                ? entry.constraint_violations
-                : Array.isArray(data.constraint_violations) ? data.constraint_violations : [];
-        issues.push(...violations.filter((item) => typeof item === "string"));
     }
     // ── Phase 2: Milestone Accumulation ──
     // Scan all completed entries in round order. For each entry, check three
@@ -575,15 +472,17 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
             milestones.push(buildMilestoneFromEntries(phaseEntries, startRound, endRound, `Rounds ${startRound}–${endRound}`, "auto"));
         }
     }
-    // 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);
+    // v3.8.1: one bound, applied identically at every prompt level. The v3.0.1
+    // sampler kept head anchors + a newest tail + an even middle sample, and
+    // deliberately did nothing at L2 — so the milestone set written to the state
+    // file depended on which level happened to compile, not on committed facts.
+    // It also did not bound growth at all (it only chose WHICH milestones to
+    // keep from an unbounded list), which is why the cap has to live here.
+    const cappedMilestones = milestones.slice(-MILESTONE_HISTORY_CAP);
     if (windowEntries.length === 0 && cappedMilestones.length === 0)
         return null;
     return makeRollingSummary({
         key_outcomes: unique(outcomes),
-        recurring_issues: unique(issues),
         rounds_sampled: windowEntries.length,
         generated_at_round: currentRound,
         failed_patterns: [],
@@ -593,188 +492,17 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
 // ═══════════════════════════════════════════════════════════════════════════
 // Sub-Goal Structured Tracking (v2.2)
 // ═══════════════════════════════════════════════════════════════════════════
-/** 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. */
 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. */
-export function deriveCriterionId(text) {
-    return "cr-" + deriveItemId(text);
-}
-/** v2.11: Check whether a user-provided reference looks like a criterion ID.
- *  Matches the pattern cr-XXXXXXXX where X is a hex digit. Module-local:
- *  consumers with the same need (round-contract.ts) keep their own copy to
- *  avoid an import cycle. */
-function isCriterionId(ref) {
-    return /^cr-[a-f0-9]{8}$/.test(ref);
-}
-/**
- * Match a user-provided description against existing SubGoals for DEDUP
- * (emerged_subtasks creation). Exact ID first, then Jaccard similarity on
- * descriptions. v3.7.1: status transitions no longer use this — they are
- * strict ID references validated before the round advances.
- */
-function matchSubGoal(target, subGoals, threshold) {
-    const trimmed = target.trim();
-    // Phase 1: Exact ID match
-    for (let i = 0; i < subGoals.length; i++) {
-        if (subGoals[i].id === trimmed)
-            return i;
-    }
-    // Phase 2: Jaccard fallback on description text
-    let bestIdx = -1;
-    let bestScore = 0;
-    for (let i = 0; i < subGoals.length; i++) {
-        const score = jaccardSimilarity(trimmed, subGoals[i].description);
-        if (score > bestScore) {
-            bestScore = score;
-            bestIdx = i;
-        }
-    }
-    return bestScore >= threshold ? bestIdx : -1;
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// Sub-goal transition matrix (v3.7.1 — single source)
-// ═══════════════════════════════════════════════════════════════════════════
-/** Closed migration matrix. done/canceled are terminal (no out-edges); the
- *  matrix rejects re-opening. blocked → in_progress is the recovery path. */
-export const SUBGOAL_TRANSITIONS = {
-    in_progress: ["pending", "blocked"],
-    done: ["pending", "in_progress", "blocked"],
-    blocked: ["pending", "in_progress"],
-    canceled: ["pending", "in_progress", "blocked"],
-};
-/** Whether a transition is legal. Same-status is a legal no-op (used by
- *  replay idempotency). References to terminal sub-goals are rejected by
- *  validateSubGoalUpdates before this is consulted. */
-export function canTransitionSubGoal(from, to) {
-    if (from === to)
-        return true;
-    return SUBGOAL_TRANSITIONS[to].includes(from);
-}
-/** Referential validation of a payload's subgoal_updates against the
- *  derived sub-goal set. Returns one error per invalid entry:
- *  unknown_id | terminal_reference | illegal_transition. */
-export function validateSubGoalUpdates(subGoals, updates) {
-    const byId = new Map(subGoals.map((sg) => [sg.id, sg]));
-    const errors = [];
-    for (const update of updates) {
-        const target = byId.get(update.id);
-        if (!target) {
-            errors.push({ id: update.id, reason: "unknown_id" });
-            continue;
-        }
-        if (target.status === "done" || target.status === "canceled") {
-            errors.push({ id: update.id, reason: "terminal_reference" });
-            continue;
-        }
-        if (!canTransitionSubGoal(target.status, update.status)) {
-            errors.push({ id: update.id, reason: "illegal_transition" });
-        }
-    }
-    return errors;
-}
-/** Apply one transition to the accumulated list. Guards make replay of
- *  committed history idempotent: terminal sub-goals never change and
- *  same-status updates are no-ops. */
-function applySubGoalUpdate(subGoals, update, rnd) {
-    const target = subGoals.find((sg) => sg.id === update.id);
-    if (!target)
-        return;
-    if (target.status === "done" || target.status === "canceled")
-        return;
-    if (!canTransitionSubGoal(target.status, update.status))
-        return;
-    if (target.status === update.status)
-        return;
-    target.status = update.status;
-    target.status_changed_at_round = rnd;
-    if (update.status === "done")
-        target.completed_at_round = rnd;
-}
-/**
- * Manage the full sub-goal lifecycle across rounds.
- *
- * v3.7.1 derivation rule: EVERY committed round (round < currentRound) is
- * replayed in round order — emerged_subtasks create pending items, then
- * subgoal_updates apply explicit transitions. The round's own report
- * (last_round_result, which the engine rebuilds from the same committed
- * evaluation) contributes the same data on the fixture path, so applying
- * it again is an idempotent no-op. Older transitions therefore never
- * regress on later compiles, and no status is ever inferred.
- */
-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)
-        .sort((a, b) => entryRound(a) - entryRound(b));
-    const subGoals = [];
-    const createEmerged = (descs, rnd) => {
-        for (const desc of descs) {
-            // Dedup: skip if an existing sub-goal is too similar
-            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,
-            }));
-        }
-    };
-    // Phase 1 — Replay every committed round in order: create, then apply
-    // that round's declared transitions.
-    for (const entry of completedEntries) {
-        const rnd = entryRound(entry);
-        createEmerged(entryEmergedSubtasks(entry), rnd);
-        for (const update of entrySubGoalUpdates(entry)) {
-            applySubGoalUpdate(subGoals, update, rnd);
-        }
-    }
-    // Phase 2 — The current round's own report (fixture/rebuild path; on the
-    // vault path this duplicates the last committed round and is idempotent).
-    if (lastRoundResult) {
-        const rnd = lastRoundResult.round || (currentRound - 1);
-        createEmerged(lastRoundResult.emerged_subtasks ?? [], rnd);
-        for (const update of lastRoundResult.subgoal_updates ?? []) {
-            applySubGoalUpdate(subGoals, update, rnd);
-        }
-    }
-    // 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
-        // (v2.14: the previous expression simplified to b.declared - a.declared,
-        // which sorted NEWEST first despite the comment)
-        if (a.status === "pending")
-            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;
-    });
-    return subGoals;
-}
+// v3.8.1: `deriveCriterionId` / `isCriterionId` moved to token-utils.ts, where
+// the other stable-id helpers live — the criterion fact derivation in
+// round-facts.ts needs them, and defining them here would make
+// round-facts ⇄ loop-compiler an import cycle. Re-exported so this module's
+// public surface ("./compiler") is unchanged.
+export { deriveCriterionId, isCriterionId } from "./token-utils.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // Time-Aware Constraint Management (v2.3)
 // ═══════════════════════════════════════════════════════════════════════════
@@ -789,19 +517,18 @@ function constraintSource(text, objective, constraintsFromPlan) {
         return "criteria";
     return "discovered";
 }
-/** Find the latest round a constraint was violated by scanning vault entries.
- *  v2.11: ID-first matching. Checks exact constraint ID match (c-XXXXXXXX)
- *  against the derived ID of each vault entry's constraint_violations, then
- *  falls back to Jaccard similarity on text. Returns 0 if never violated. */
-/** True when a reported violation text matches a constraint text — same
- *  ID-first + Jaccard fallback matching as findLastViolatedRound. */
+/** True when a reported violation text matches a constraint text.
+ *  v2.11: ID-first — an exact `c-XXXXXXXX` match against the derived id.
+ *  v3.8.1: the Jaccard fallback is gone; the remaining arm requires the
+ *  reported text to be EXACTLY equal to the constraint after normalization,
+ *  so a reported violation can no longer attach itself to a constraint it
+ *  merely resembles. */
 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;
+    return normalizeText(text) === normalizeText(violation);
 }
 function findLastViolatedRound(text, vaultEntries) {
     let latest = 0;
@@ -853,7 +580,7 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
         // (its own Success Criteria section and the verification gate's
         // criteriaMatch are ID-first on cr-). Rendering it under c-XXXXXXXX in
         // the active list meant the same text carried two IDs in one prompt,
-        // and an agent echoing the active-list ID into success_criteria_met
+        // and an agent echoing the active-list ID into its criterion claims
         // could never match.
         metadata.push(makeConstraintMeta({
             id: source === "criteria" ? deriveCriterionId(text) : deriveConstraintId(text),
@@ -866,38 +593,6 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
     }
     return { active, metadata };
 }
-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 >= threshold,
-        alignment_score: Number(score.toFixed(2)),
-        warning: score < threshold ? "Current task may be drifting from the loop objective." : "",
-        escalation: score < threshold ? "warn" : "none",
-    });
-}
-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 integrity = Math.max(0, 1 - violations * 0.2);
-    const continuity = previous ? jaccardSimilarity(previous.task, request.task) : 1;
-    // 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,
-        drift_detected: drift,
-        strategy_stability: true,
-        task_continuity: Number(continuity.toFixed(2)),
-        escalation_recommended: drift || integrity < 0.6 ? "l2" : "none",
-    });
-}
 function levelDecision(request, context) {
     const previous = getPreviousRound(request.loop_id, request.round - 1, context);
     const last = request.last_round_result;
@@ -908,11 +603,6 @@ function levelDecision(request, context) {
         last?.retracted_constraints?.length ||
         last?.revised_success_criteria?.length ||
         last?.wrong_assumptions?.length);
-    const lastFullRound = loopEntries(request.loop_id, context)
-        .filter((entry) => entryLineage(entry).recompile_level === "l2")
-        .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
@@ -933,14 +623,12 @@ function levelDecision(request, context) {
         verificationContradicted: (request.verification_flags ?? [])
             .some((flag) => flag.severity === "error"),
         consecutiveRejections: request.consecutive_rejections,
-        fullRefreshInterval: getPolicy().prompt.full_refresh_interval,
-        lastFullRound,
     });
 }
 export function decideLevel(request, context) {
     return levelDecision(request, context).level;
 }
-export function buildSelfEvalBlock(round, prevDriftFlags,
+export function buildSelfEvalBlock(round,
 /** 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. */
@@ -950,16 +638,7 @@ level,
  *  `activeContract != null`). Only then does the template ask the agent
  *  to restate/propose it — a generic empty contract template would invite
  *  placeholder submissions that trigger round_underspecified noise. */
-hasContract = false,
-/** v3.5: L2-only prose suggesting a Round Contract declaration when the
- *  Current Task is NOT one (contract_nudge_on_l2 policy, computed at the
- *  compileLoop call site). Mutually exclusive with hasContract. The prose
- *  must never contain the JSON key name `round_contract` — contract-less
- *  L2 tests assert its lowercase absence. */
-proposalNudge = false) {
-    const hasIntentDrift = prevDriftFlags?.some(f => f.check === "intent_drift") ?? false;
-    const hasSubGoalDrift = prevDriftFlags?.some(f => f.check === "subgoal_drift") ?? false;
-    const needsClarification = hasIntentDrift || hasSubGoalDrift;
+hasContract = false) {
     const declareOutcome = level !== "l0";
     const restateContract = hasContract && declareOutcome;
     const evalObj = {
@@ -969,24 +648,31 @@ proposalNudge = false) {
         should_continue: true,
         discovered_constraints: ["<new constraint>"],
         emerged_subtasks: [],
-        execution_evidence: {
+        execution_report: {
             files_changed: [],
-            test_results: { passed: 0, failed: 0, skipped: 0 },
-            success_criteria_met: ["<cr-XXXXXXXX or text>"],
-            success_criteria_remaining: ["<cr-XXXXXXXX or text>"],
+            tests_reported: { passed: 0, failed: 0, skipped: 0 },
+            // The contract claim is functional (it is what advances an item), so it
+            // stays at every level. The advisory criterion claim is an L1/L2
+            // addition — the L0 retry template is a lean delta kept under budget.
+            contract_item_claims: [
+                { item_id: "<rci-XXXXXXXX from the Current Task>", outcome: "met" },
+            ],
             progress_estimate: 0,
         },
         wrong_assumptions: [],
-        next_action: "<next concrete action, or empty when complete>",
         subgoal_updates: [
             { id: "<sg-XXXXXXXX from the Sub-Goal Dashboard>", status: "done" },
         ],
     };
-    // v2.12: Declarative tri-state outcome (L1/L2 only — keeps L0 retry lean)
+    // v2.12: Declarative 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 = [];
+        // v3.8: the advisory criterion claim rides with the other L1/L2 additions.
+        evalObj.execution_report.criterion_claims = [
+            { criterion_id: "<cr-XXXXXXXX or text>", outcome: "met" },
+        ];
     }
     // v3.3/v3.4: Round Contract proposal template (L1/L2, active-contract
     // rounds only — L0 retry stays lean, and rounds without an active
@@ -1002,26 +688,12 @@ proposalNudge = false) {
             scope: [],
         };
     }
-    // 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(" / ");
-        evalObj.drift_clarification =
-            `<explain why your Round ${round} actions diverged from your stated plan ` +
-                `(${flagTypes} detected in previous round). ` +
-                `Leave empty if no divergence occurred>`;
-    }
     const lines = [
         "### LoopForge Evaluation (Required)",
         "",
         `After completing Round ${round}, replace the placeholder values below`,
         "with your actual results and pass this object as `loopforge_next.evaluation`.",
     ];
-    if (needsClarification) {
-        lines.push("", "> ⚠️ **Drift Detected:** The verification gate detected that your previous", "> round's declared intent (next_action) did not match your actual output.", "> Please explain the pivot in the `drift_clarification` field below.", "> An honest explanation helps the enforcement gate distinguish intentional", "> course corrections from unacknowledged drift.");
-    }
     lines.push("```json");
     lines.push(JSON.stringify(evalObj, null, 2));
     lines.push("```");
@@ -1031,13 +703,8 @@ proposalNudge = false) {
     lines.push("Use IDs for exact matching: c-XXXXXXXX, cr-XXXXXXXX, sg-XXXXXXXX.");
     lines.push("Sub-goal changes go through `subgoal_updates` (active sub-goal IDs only;");
     lines.push("done/canceled are terminal — reopen via `emerged_subtasks`; bad IDs reject).");
-    // v3.5: L2 contract-less nudge (prose only — never the JSON key name, so
-    // contract-less rounds keep their template-lean assertions).
-    if (proposalNudge) {
-        lines.push("", "If the remaining work will span several rounds, consider declaring a", "Round Contract for the next round — list its done_when items, the", "verification_plan commands that will back them, and the scope. This", "keeps each round's boundary machine-checkable.");
-    }
     if (restateContract) {
-        lines.push("Round Contract: restate the Current Task's contract UNCHANGED in", "`round_contract` (work_item/done_when/verification_plan/scope) and run", "its Verify commands; list satisfied done_when items in", "`success_criteria_met`. When the current contract's done_when items are", "all satisfied, or the round is blocked (outcome=blocked + blocker),", "declare the NEXT round's contract instead (or omit `round_contract`", "when the whole task is done — the Current Task reverts to the", "original task).");
+        lines.push("Round Contract: restate the Current Task's contract UNCHANGED in", "`round_contract` (work_item/items/scope) and run each item's Verify", "commands; claim the items you completed in", "`execution_report.contract_item_claims` using the `rci-XXXXXXXX` ids", "the Current Task renders. An item only becomes verified when its bound", "command is observed passing — a claim alone leaves it insufficient.", "When every item is verified, or the round is blocked (outcome=blocked", "+ blocker), declare the NEXT round's contract instead (or omit", "`round_contract` when the whole task is done — the Current Task", "reverts to the original task).");
     }
     return lines.join("\n");
 }
@@ -1054,32 +721,22 @@ function committedBacktrackBrief(loopId, round, context) {
     const entry = loopEntries(loopId, context).find((e) => entryLineage(e).committed_action === "backtrack" && entryRound(e) === round);
     if (!entry)
         return undefined;
-    // Read the facts the engine stamped onto the merged lineage entry from
-    // the committed rollback decision (engine.ts mergeCommittedRound).
-    const lineage = entryLineage(entry);
-    const asStrings = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
-    const asNumbers = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "number") : [];
-    const failedRounds = asNumbers(lineage.backtrackFailedRounds);
-    const approaches = asStrings(lineage.backtrackApproaches).slice(0, 6);
-    const assumptions = asStrings(lineage.backtrackWrongAssumptions).slice(0, 5);
-    const target = typeof lineage.backtrackTarget === "number" ? lineage.backtrackTarget : 0;
-    const trigger = typeof lineage.backtrackTriggerRule === "string"
-        ? lineage.backtrackTriggerRule
-        : "unknown";
-    const lines = [
-        `- **Trigger**: ${trigger}`,
-        `- **Restored to round**: ${target} (redo round ${target + 1})`,
-    ];
-    if (failedRounds.length > 0)
-        lines.push(`- **Failed rounds**: ${failedRounds.join(", ")}`);
-    for (const approach of approaches)
-        lines.push(`  - Failed approach: ${approach}`);
-    if (assumptions.length > 0) {
-        lines.push("- **Falsified assumptions** (do not rebuild on these):");
-        for (const assumption of assumptions)
-            lines.push(`  - ${assumption}`);
-    }
-    return lines;
+    // v3.8.1: one decoder for the committed rollback record and one renderer for
+    // the brief. The facts ride on the merged lineage entry (engine.ts stamps
+    // them from the committed decision) and the same `decodeBacktrackRecord`
+    // reads the durable :feedback envelope, so both carriers decode to one shape
+    // — and this brief and the rollback prompt no longer render the same
+    // rollback with two hand-written line builders.
+    const record = decodeBacktrackRecord(entryLineage(entry));
+    if (!record)
+        return undefined;
+    return recoveryBriefLines({
+        target: record.target,
+        triggerRule: record.triggerRule,
+        failedRounds: record.failedRounds,
+        approaches: record.approaches,
+        wrongAssumptions: record.wrongAssumptions,
+    });
 }
 export function compileLoop(request, context) {
     const decision = levelDecision(request, context);
@@ -1087,45 +744,76 @@ export function compileLoop(request, context) {
     const objective = evolveObjective(request, 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);
+    const rolling = buildRollingSummary(request.loop_id, request.round, context, 0);
+    // v3.8: ONE committed-round derivation feeds every projection below
+    // (sub-goals, the active contract, its item statuses, criteria).
+    const windowRounds = derivationRounds(loopEntries(request.loop_id, context), request.round);
+    // v3.8: sub-goal lifecycle lives in subgoal-state.ts and consumes the
+    // shared committed-round view — one history interpretation.
+    const subGoals = deriveSubGoals({
+        loopId: request.loop_id,
+        currentRound: request.round,
+        rounds: windowRounds,
+        currentReport: request.last_round_result
+            ? {
+                round: request.last_round_result.round || (request.round - 1),
+                emergedSubtasks: request.last_round_result.emerged_subtasks ?? [],
+                subgoalUpdates: request.last_round_result.subgoal_updates ?? [],
+            }
+            : null,
+    });
+    // v3.4/v3.8/v3.8.1: the ACTIVE Round Contract, its per-item statuses and the
+    // verified sub-goal facts for this compile — ONE `deriveRoundFacts` call,
+    // the same bundle the projection consumes. Derived from committed rounds, so
+    // rejection retries, resume, unpause and backtrack compiles (which carry no
+    // last_round_result) keep showing the same contract, and a verified or
+    // blocked contract stops being shown. A verified item stays proven after its
+    // contract closes because the bundle reads the whole history, not the active
+    // contract. The compile path has no in-flight observations of its own.
+    const roundFacts = deriveRoundFacts({
+        rounds: windowRounds,
+        currentRound: request.round,
+        inFlight: NO_IN_FLIGHT_ROUND,
+        subGoals,
+        commands: getPolicy().evidence.commands ?? [],
+    });
+    // `roundFacts.verifiedSubGoals` is not read here — it reaches the state file
+    // and the projection through the bundle itself.
+    const { activeContract } = roundFacts;
     // 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 criterionStatuses = deriveCriterionStatuses(request.loop_id, context, objective, request.round, request.last_round_result, roundFacts.criterionFacts);
+    // v3.8.1: the ONE recurring-fact derivation, over the shared window. The
+    // prompt renders its recent tail; the state file renders the recurring set.
+    const recurringFlags = deriveRecurringFlags(windowRounds);
+    // v3.8.1: a same-round exact repeat is the only sub-goal duplication the
+    // runtime can state as a fact — those entries really were dropped, so the
+    // agent is told. The cross-round near-duplicate similarity diagnostic is
+    // gone with the rest of the fuzzy matching, and so are the task-alignment
+    // and loop-health warnings: both were Jaccard scores over task/objective
+    // text, never machine facts.
+    const repeatedDeclarations = duplicateEmergedDeclarations(request.last_round_result?.emerged_subtasks ?? []);
     const warnings = unique([
-        alignment.warning,
-        health.escalation_recommended !== "none"
-            ? `Loop health recommends ${health.escalation_recommended}.`
+        repeatedDeclarations.length > 0
+            ? `duplicate_declaration: ${repeatedDeclarations.length} sub-goal ` +
+                `declaration(s) repeated an earlier entry in the same round and were ` +
+                `not created: ${repeatedDeclarations.join("; ")}`
             : "",
     ]);
-    // ── 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.
+    // v3.8.1: the agent trust score and trend are deleted. The score was
+    // `1 - errors*0.15 - warns*0.03` — arbitrary weights with no machine
+    // meaning, re-encoding flag counts that are already visible. The trend was
+    // worse: `1 - violations*0.1` per round, computed from
+    // `constraint_violations`, i.e. a DIFFERENT source from the score it was
+    // displayed next to. "Trend" was therefore not the score's history at all.
+    // Neither fed a decision.
     const completedEntries = loopEntries(request.loop_id, context)
         .filter((e) => entryRound(e) >= 1 && entryRound(e) < request.round);
-    const committedRounds = mergedRoundsFromEntries(completedEntries, request.round);
-    const trend = [];
-    for (const round of committedRounds.slice(-10)) {
-        const viols = round.evaluation?.constraint_violations ?? [];
-        // Simple proxy: no violations = perfect trust, each violation = -0.1
-        const score = Math.max(0, 1.0 - viols.length * 0.1);
-        trend.push(Number(score.toFixed(2)));
-    }
-    // v3.3: Round stats + machine git-motion status (display-only, derived).
-    const roundStats = deriveRoundStats(committedRounds);
+    const committedRounds = derivationRounds(completedEntries, request.round);
+    // v3.3/v3.8.1: machine git-motion (display-only, derived). The per-round
+    // "round stats" table is deleted: its only renderer was the L2 prompt
+    // section removed above, so it was computed, put into the canonical state
+    // (and therefore into stateHash) and read by nothing.
     const machineStatus = deriveMachineStatus(committedRounds, request.round);
-    // v3.4: ACTIVE Round Contract for this compile — derived from committed
-    // rounds, so rejection retries / resume / unpause / backtrack compiles
-    // (no last_round_result) keep showing the contract as Current Task, and a
-    // satisfied or blocked contract stops being shown.
-    const activeContract = deriveActiveContract(request.loop_id, context, request.round);
     const response = makeLoopCompileResponse({
         status: AgentStatus.OK,
         recompile_level: decision.level,
@@ -1139,16 +827,10 @@ export function compileLoop(request, context) {
         goal_id: deriveGoalId(request.loop_id, request.task, request.goal_id),
         goal_text_hash: computeGoalTextHash(request.task),
         loop_objective: objective,
-        loop_health: health,
-        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() ||
-            request.last_round_result?.emerged_subtasks?.[0] || "",
+        recurring_flags: recurringFlags,
         plan_source: request.plan_source,
         warnings,
     });
@@ -1161,10 +843,11 @@ export function compileLoop(request, context) {
         ? `${policy.state_file.directory}/${request.loop_id}-state.md`
         : "";
     const state = createCanonicalLoopState(request, response, statePath, {
-        roundStats,
         machineStatus,
-        // v3.4: derived active contract — the Current Task's source of truth.
-        roundContract: activeContract,
+        // v3.4/v3.8.1: the contract-fact bundle — the Current Task's source of
+        // truth, its verification view and the machine-verified sub-goal facts as
+        // ONE derivation. The static capability rides on the state itself.
+        roundFacts,
     });
     const markdown = renderCanonicalStateMarkdown(state, {
         // v3.7.1: retry attempts are marked in the derived view (attempt is
@@ -1174,13 +857,12 @@ export function compileLoop(request, context) {
         attempt: request.attempt,
         recoveryBrief: committedBacktrackBrief(request.loop_id, request.round, context),
     });
-    // 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;
+    // v3.8.1: the L2 budget is a FIXED ceiling. The v2.4 adaptive budget
+    // scaled it by round count, milestone count and sub-goal count, which made
+    // the prompt's allowed content depend on how long the loop had been running
+    // rather than on the facts of this round — the same loop could render a
+    // section at round 5 and silently drop it at round 50.
+    //
     // 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.
@@ -1195,23 +877,17 @@ export function compileLoop(request, context) {
         budgets: {
             l0: policy.prompt.l0_max_chars,
             l1: policy.prompt.l1_max_chars,
-            l2: adaptiveL2,
+            l2: policy.prompt.l2_max_chars,
         },
         attempt: request.attempt,
-        selfEvaluationBlock: buildSelfEvalBlock(request.round, request.verification_flags, decision.level,
+        selfEvaluationBlock: buildSelfEvalBlock(request.round, decision.level,
         // v3.4: restate the contract only when this prompt's Current Task IS
         // the ACTIVE contract (derived — not the previous submission's field,
         // which is a proposal and may differ from what this round executes).
-        activeContract != null,
-        // v3.5: L2-only declaration nudge when nothing is active (policy-gated;
-        // mutually exclusive with the restate template above).
-        decision.level === "l2" && activeContract === null &&
-            getPolicy().prompt.contract_nudge_on_l2),
+        activeContract != null),
         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;