loopforge 3.6.0 → 3.7.1

package/dist/loop-compiler.js

@@ -7,7 +7,7 @@ import { createHash } from "node:crypto";
 import { getPolicy } from "./policy.js";
 import { AgentStatus, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeConstraintMeta, makeMilestoneSummary, makeRollingSummary, makeSubGoal, makeTaskAlignment, } from "./protocol.js";
 import { createCanonicalLoopState, renderCanonicalStateMarkdown, } from "./canonical-state.js";
-import { decodeCommittedRound, decodeMergedRound, machineGitMotionSeries, mergedRoundsFromEntries, } from "./committed-round.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 { assemblePromptArtifact } from "./prompt-assembler.js";
 import { decidePromptLevel, } from "./prompt-policy.js";
@@ -17,15 +17,9 @@ function contextEntries(context) {
         return [];
     return context.results.filter((value) => value !== null && typeof value === "object" && !Array.isArray(value));
 }
-function lineage(entry) {
-    const value = entry.loop_lineage ?? entry.lineage;
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
 function loopEntries(loopId, context) {
     return contextEntries(context)
-        .filter((entry) => entry.loop_id === loopId || lineage(entry).loop_id === loopId)
+        .filter((entry) => entry.loop_id === loopId || entryLineage(entry).loop_id === loopId)
         .sort((a, b) => entryRound(a) - entryRound(b));
 }
 /** v3.3.1: The canonical entry for a round — its compile-time lineage entry
@@ -51,12 +45,6 @@ function roundCanonicalEntry(entries, round) {
         }) ??
         null);
 }
-/** Return the canonical read model when an entry is a committed round.
- * Uncommitted compiler lineage has no durable decision yet and deliberately
- * remains on the local compile path; it cannot be treated as history. */
-function committedView(entry) {
-    return decodeMergedRound(entry) ?? decodeCommittedRound(entry);
-}
 export function computeGoalTextHash(text) {
     const normalized = text.trim().replace(/\s+/g, " ").toLowerCase();
     return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
@@ -75,7 +63,7 @@ export function readPresentedBaseline(loopId, round, context) {
     const entry = roundCanonicalEntry(loopEntries(loopId, context), round - 1);
     if (!entry)
         return null;
-    const data = lineage(entry);
+    const data = entryLineage(entry);
     const constraintIds = data.presented_constraint_ids;
     const subGoals = data.presented_subgoals;
     const milestoneRanges = data.presented_milestone_ranges;
@@ -97,7 +85,7 @@ export function getPreviousRound(loopId, round, context) {
     const entry = roundCanonicalEntry(loopEntries(loopId, context), round);
     if (!entry)
         return null;
-    const data = lineage(entry);
+    const data = entryLineage(entry);
     return {
         round,
         goal_id: typeof data.goal_id === "string" ? data.goal_id : "",
@@ -156,9 +144,16 @@ function evolveObjective(request, context) {
     let version = current.version ?? 1;
     if (last?.objective_refinement?.trim()) {
         const refinement = last.objective_refinement.trim();
-        history.push(refinement);
-        objective = `${objective}\nRefinement: ${refinement}`;
-        version++;
+        // M5: fold each refinement exactly once per persisted objective state.
+        // A retry recompiles the same round against the same committed
+        // last_round_result; without this guard every retry attempt re-appends
+        // the refinement and inflates the version — the objective text and the
+        // state file grew "Refinement: X" once per attempt.
+        if (!history.includes(refinement)) {
+            history.push(refinement);
+            objective = `${objective}\nRefinement: ${refinement}`;
+            version++;
+        }
     }
     const revisions = new Map((last?.revised_success_criteria ?? []).map((item) => [item.old, item.new]));
     return makeLoopObjective({
@@ -188,7 +183,7 @@ function evolveConstraints(request, objective, previous, context) {
     const lastRetractedRound = new Map();
     if (window > 0) {
         for (const entry of loopEntries(request.loop_id, context)) {
-            const retractedList = lineage(entry).retracted_constraints;
+            const retractedList = entryLineage(entry).retracted_constraints;
             if (!Array.isArray(retractedList))
                 continue;
             const rnd = entryRound(entry);
@@ -221,47 +216,6 @@ function evolveConstraints(request, objective, previous, context) {
 // ═══════════════════════════════════════════════════════════════════════════
 // Hierarchical Summary (v2.1)
 // ═══════════════════════════════════════════════════════════════════════════
-/** Extract execution_evidence from a vault entry, handling both direct-field
- *  and lineage-nested shapes. Returns null when absent. */
-function entryExecutionEvidence(entry) {
-    const view = committedView(entry);
-    if (view)
-        return view.executionEvidence;
-    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 view = committedView(entry);
-    if (view)
-        return view.executionEvidence?.success_criteria_met
-            ?.filter((value) => typeof value === "string") ?? [];
-    const ev = entryExecutionEvidence(entry);
-    if (!ev)
-        return [];
-    const arr = ev.success_criteria_met;
-    return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
-}
-/** Read success_criteria_remaining from an entry's execution_evidence. */
-function entryCriteriaRemaining(entry) {
-    const view = committedView(entry);
-    if (view)
-        return view.executionEvidence?.success_criteria_remaining
-            ?.filter((value) => typeof value === "string") ?? [];
-    const ev = entryExecutionEvidence(entry);
-    if (!ev)
-        return [];
-    const arr = ev.success_criteria_remaining;
-    return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
-}
 /** v3.2: Deterministic lessons learned — constraints violated repeatedly or
  *  verification checks failing repeatedly across rounds (full history, unlike
  *  the enforcement gate's R2 3-round window). Presentation only: the output
@@ -273,7 +227,7 @@ export function deriveLessons(loopId, context, currentRound) {
     const warns = new Map();
     for (const entry of entries) {
         const rnd = entryRound(entry);
-        const view = committedView(entry);
+        const view = decodeRound(entry);
         const viols = view
             ? view.constraintViolations ?? []
             : Array.isArray(entry.constraint_violations)
@@ -454,41 +408,10 @@ function detectNewCriteria(current, previous) {
         return currMet;
     return currMet.filter((curr) => prevMet.every((prev) => !criteriaMatch(curr, prev)));
 }
-/** Read constraints_active from an entry's lineage. */
-function entryActiveConstraints(entry) {
-    const view = committedView(entry);
-    if (view)
-        return view.activeConstraints ?? [];
-    const lin = lineage(entry);
-    const arr = lin.constraints_active;
-    return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
-}
-/** Read retracted_constraints from an entry. */
-function entryRetractedConstraints(entry) {
-    const view = committedView(entry);
-    if (view)
-        return view.retractedConstraints ?? [];
-    const direct = entry.retracted_constraints;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    const lin = lineage(entry);
-    const nested = lin.retracted_constraints;
-    if (Array.isArray(nested))
-        return nested.filter((v) => typeof v === "string");
-    return [];
-}
-/** Read progress_estimate from an entry's execution_evidence. */
-function entryProgressEstimate(entry) {
-    const ev = entryExecutionEvidence(entry);
-    if (!ev)
-        return 0;
-    const pe = ev.progress_estimate;
-    return typeof pe === "number" ? pe : 0;
-}
 /** Build a single MilestoneSummary from a range of completed round entries. */
 function buildMilestoneFromEntries(phaseEntries, startRound, endRound, label, kind) {
     const last = phaseEntries.at(-1);
-    const lastView = last ? committedView(last) : null;
+    const lastView = last ? decodeRound(last) : null;
     const outcomeRaw = lastView
         ? (lastView.outputSummary ?? "")
         : last && typeof last.output_summary === "string" ? last.output_summary : "";
@@ -572,8 +495,8 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
     const outcomes = [];
     const issues = [];
     for (const entry of windowEntries) {
-        const view = committedView(entry);
-        const data = lineage(entry);
+        const view = decodeRound(entry);
+        const data = entryLineage(entry);
         const round = entryRound(entry);
         const success = view ? view.success : entry.success ?? data.success;
         const summary = view
@@ -606,7 +529,7 @@ export function buildRollingSummary(loopId, currentRound, context, sinceRound =
     for (let i = 0; i < completedEntries.length; i++) {
         const entry = completedEntries[i];
         const rnd = entryRound(entry);
-        const lin = lineage(entry);
+        const lin = entryLineage(entry);
         // Signal 1: Agent-declared checkpoint
         const isAgentCheckpoint = lin.compression_checkpoint === true;
         // Signal 2: New criteria met (compare with previous vault entry)
@@ -685,66 +608,18 @@ export function deriveConstraintId(text) {
 export function deriveCriterionId(text) {
     return "cr-" + deriveItemId(text);
 }
-/** v2.11: Check whether a user-provided reference looks like a constraint ID.
- *  Matches the pattern c-XXXXXXXX where X is a hex digit. */
-export function isConstraintId(ref) {
-    return /^c-[a-f0-9]{8}$/.test(ref);
-}
 /** v2.11: Check whether a user-provided reference looks like a criterion ID.
- *  Matches the pattern cr-XXXXXXXX where X is a hex digit. */
-export function isCriterionId(ref) {
+ *  Matches the pattern cr-XXXXXXXX where X is a hex digit. Module-local:
+ *  consumers with the same need (round-contract.ts) keep their own copy to
+ *  avoid an import cycle. */
+function isCriterionId(ref) {
     return /^cr-[a-f0-9]{8}$/.test(ref);
 }
-/** Read emerged_subtasks from a vault entry (handles direct + lineage nesting). */
-function entryEmergedSubtasks(entry) {
-    const view = committedView(entry);
-    if (view)
-        return view.emergedSubtasks ?? [];
-    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 view = committedView(entry);
-    if (view)
-        return view.completedSubtasks ?? [];
-    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 view = committedView(entry);
-    if (view)
-        return view.blockedSubtasks ?? [];
-    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 view = committedView(entry);
-    if (view)
-        return view.canceledSubtasks ?? [];
-    const direct = entry.canceled_subtasks;
-    if (Array.isArray(direct))
-        return direct.filter((v) => typeof v === "string");
-    return [];
-}
 /**
- * Match a user-provided sub-task reference against existing SubGoals.
- *
- * Tries exact SubGoal ID match first (e.g. "sg-a3f2b1c0"), then falls
- * back to Jaccard token similarity on descriptions. Returns the index
- * of the best-matching SubGoal, or -1 when no match reaches threshold.
+ * 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();
@@ -765,34 +640,90 @@ function matchSubGoal(target, subGoals, threshold) {
     }
     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.
  *
- * 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
+ * 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);
+    const completedEntries = allEntries
+        .filter((e) => entryRound(e) >= 1 && entryRound(e) < currentRound)
+        .sort((a, b) => entryRound(a) - entryRound(b));
     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);
+    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,
+                id: deriveSubGoalId(desc),
                 description: desc.trim(),
                 status: "pending",
                 declared_at_round: rnd,
@@ -800,80 +731,23 @@ function manageSubGoals(loopId, currentRound, lastRoundResult, vaultContext) {
                 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 — Process current round's sub-task declarations
+    // 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);
-        // 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;
-                        }
-                    }
-                }
-            }
+        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
@@ -915,40 +789,6 @@ function constraintSource(text, objective, constraintsFromPlan) {
         return "criteria";
     return "discovered";
 }
-/** Find the earliest round a constraint was discovered by scanning vault entries.
- *  v2.11: ID-first matching. Checks exact constraint ID match (c-XXXXXXXX)
- *  against the derived ID of each vault entry's discovered_constraints, then
- *  falls back to Jaccard similarity on text. */
-function findDiscoveredRound(text, vaultEntries) {
-    const targetId = deriveConstraintId(text);
-    let earliest = 0;
-    for (const entry of vaultEntries) {
-        const rnd = entryRound(entry);
-        if (rnd < 1)
-            continue;
-        const view = committedView(entry);
-        const discovered = view
-            ? view.discoveredConstraints ?? []
-            : Array.isArray(entry.discovered_constraints)
-                ? entry.discovered_constraints.filter((v) => typeof v === "string")
-                : [];
-        for (const d of discovered) {
-            // Phase 1: exact ID match (v2.11)
-            if (d === targetId || deriveConstraintId(d) === targetId) {
-                if (earliest === 0 || rnd < earliest)
-                    earliest = rnd;
-                break;
-            }
-            // Phase 2: Jaccard fallback for natural-language references.
-            if (jaccardSimilarity(text, d) >= getPolicy().evolution.constraint_match_threshold) {
-                if (earliest === 0 || rnd < earliest)
-                    earliest = rnd;
-                break;
-            }
-        }
-    }
-    return earliest;
-}
 /** Find the latest round a constraint was violated by scanning vault entries.
  *  v2.11: ID-first matching. Checks exact constraint ID match (c-XXXXXXXX)
  *  against the derived ID of each vault entry's constraint_violations, then
@@ -969,7 +809,7 @@ function findLastViolatedRound(text, vaultEntries) {
         const rnd = entryRound(entry);
         if (rnd < 1)
             continue;
-        const view = committedView(entry);
+        const view = decodeRound(entry);
         const violations = view
             ? view.constraintViolations ?? []
             : Array.isArray(entry.constraint_violations)
@@ -986,15 +826,17 @@ function findLastViolatedRound(text, vaultEntries) {
     return latest;
 }
 /**
- * Manage constraint lifecycle with time-aware decay.
+ * Manage constraint lifecycle metadata for the active set.
  *
- * Discovered constraints that haven't been violated for N rounds are demoted
- * to inactive — removed from prompts but kept in state. Hard/plan/criteria
- * constraints never auto-decay. Inactive constraints are auto-reactivated
- * if violated again in the current round.
+ * v3.7: the v2.3 time-aware decay (discovered constraints demoted to
+ * inactive after N quiet rounds, auto-reactivation on a fresh violation)
+ * is gone — every active constraint stays active. What remains is the
+ * display metadata the v3 prompt surface needs: per-text source
+ * classification (v3.3.1: criteria texts carry the cr-XXXXXXXX namespace),
+ * and last_violated_at_round for the L1 collapse "(violated this round)"
+ * annotation (diffConstraints compares it to the current round).
  */
 function manageConstraintLifecycle(active, objective, constraintsFromPlan, vaultContext, currentRound, lastRoundViolations = []) {
-    const policy = getPolicy().evolution;
     const allEntries = loopEntries(objective.loop_id || "", vaultContext);
     const completedEntries = allEntries.filter((e) => entryRound(e) >= 1 && entryRound(e) < currentRound);
     const metadata = [];
@@ -1004,57 +846,25 @@ function manageConstraintLifecycle(active, objective, constraintsFromPlan, vault
         // as a violation at currentRound — the previous rounds' scan cannot see
         // it (this round is not committed yet). This makes the L1 collapse
         // render "(violated this round)" (diffConstraints compares
-        // last_violated_at_round === round) and re-activates decayed
-        // discovered constraints.
+        // last_violated_at_round === round).
         const violatedThisRound = lastRoundViolations.some((v) => matchesConstraintText(text, v));
-        // Structural constraints never decay
-        if (source === "hard" || source === "plan" || source === "criteria") {
-            // v3.3.1: one text, one identity — a success-criterion text that also
-            // lives in the merged active set belongs to the cr-XXXXXXXX namespace
-            // (its own Success Criteria section and the verification gate's
-            // criteriaMatch are ID-first on cr-). Rendering it under c-XXXXXXXX in
-            // the active list meant the same text carried two IDs in one prompt,
-            // and an agent echoing the active-list ID into success_criteria_met
-            // could never match.
-            metadata.push(makeConstraintMeta({
-                id: source === "criteria" ? deriveCriterionId(text) : deriveConstraintId(text),
-                text,
-                discovered_at_round: objective.created_at_round || 1,
-                last_violated_at_round: violatedThisRound
-                    ? currentRound
-                    : findLastViolatedRound(text, completedEntries),
-                source,
-                status: "active",
-            }));
-            continue;
-        }
-        // Discovered constraints: check for inactivity
-        const discoveredAt = findDiscoveredRound(text, completedEntries);
-        const lastViolated = violatedThisRound
-            ? currentRound
-            : findLastViolatedRound(text, completedEntries);
-        const roundsSinceRelevant = lastViolated > 0
-            ? currentRound - lastViolated
-            : currentRound - (discoveredAt || currentRound);
-        const status = roundsSinceRelevant > policy.constraint_inactive_rounds
-            ? "inactive"
-            : "active";
+        // v3.3.1: one text, one identity — a success-criterion text that also
+        // lives in the merged active set belongs to the cr-XXXXXXXX namespace
+        // (its own Success Criteria section and the verification gate's
+        // criteriaMatch are ID-first on cr-). Rendering it under c-XXXXXXXX in
+        // the active list meant the same text carried two IDs in one prompt,
+        // and an agent echoing the active-list ID into success_criteria_met
+        // could never match.
         metadata.push(makeConstraintMeta({
-            id: deriveConstraintId(text),
+            id: source === "criteria" ? deriveCriterionId(text) : deriveConstraintId(text),
             text,
-            discovered_at_round: discoveredAt || 0,
-            last_violated_at_round: lastViolated,
-            source: "discovered",
-            status,
+            last_violated_at_round: violatedThisRound
+                ? currentRound
+                : findLastViolatedRound(text, completedEntries),
+            source,
         }));
     }
-    const newActive = metadata
-        .filter((m) => m.status === "active")
-        .map((m) => m.text);
-    const inactive = metadata
-        .filter((m) => m.status === "inactive")
-        .map((m) => m.text);
-    return { active: newActive, inactive, metadata };
+    return { active, metadata };
 }
 export function alignTask(proposedTask, request, context) {
     const objective = request.loop_objective ?? latestObjective(request.loop_id, context);
@@ -1099,7 +909,7 @@ function levelDecision(request, context) {
         last?.revised_success_criteria?.length ||
         last?.wrong_assumptions?.length);
     const lastFullRound = loopEntries(request.loop_id, context)
-        .filter((entry) => lineage(entry).recompile_level === "l2")
+        .filter((entry) => entryLineage(entry).recompile_level === "l2")
         .map(entryRound)
         .filter((round) => round < request.round)
         .at(-1) ?? 1;
@@ -1108,7 +918,7 @@ function levelDecision(request, context) {
     // rehydration (the decidePromptLevel recovery_boundary branch existed
     // but no caller ever set it).
     const recoveryBoundary = loopEntries(request.loop_id, context)
-        .some((entry) => lineage(entry).committed_action === "backtrack" &&
+        .some((entry) => entryLineage(entry).committed_action === "backtrack" &&
         entryRound(entry) === request.round);
     return decidePromptLevel({
         round: request.round,
@@ -1130,17 +940,17 @@ function levelDecision(request, context) {
 export function decideLevel(request, context) {
     return levelDecision(request, context).level;
 }
-export function buildSelfEvalBlock(round, prevDriftFlags, 
+export function buildSelfEvalBlock(round, prevDriftFlags,
 /** v2.12: L0 is the minimal retry template — the v2.12 declarative fields
  *  (outcome/blocker/retroactiveClaims) are L1/L2 additions so the retry
  *  prompt stays within its tight budget. */
-level, 
+level,
 /** v3.3/v3.4: Whether this round's Current Task IS the ACTIVE Round
  *  Contract (derived from committed rounds — compileLoop passes
  *  `activeContract != null`). Only then does the template ask the agent
  *  to restate/propose it — a generic empty contract template would invite
  *  placeholder submissions that trigger round_underspecified noise. */
-hasContract = false, 
+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
@@ -1168,9 +978,9 @@ proposalNudge = false) {
         },
         wrong_assumptions: [],
         next_action: "<next concrete action, or empty when complete>",
-        completed_subtasks: ["<sg-XXXXXXXX or text>"],
-        blocked_subtasks: ["<sg-XXXXXXXX or text>"],
-        canceled_subtasks: ["<sg-XXXXXXXX or text>"],
+        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)
     if (declareOutcome) {
@@ -1219,7 +1029,8 @@ proposalNudge = false) {
     lines.push("IMPORTANT: Replace every <placeholder> with your actual data.");
     lines.push("Set success=true only when the full goal and ALL hard constraints are verified.");
     lines.push("Use IDs for exact matching: c-XXXXXXXX, cr-XXXXXXXX, sg-XXXXXXXX.");
-    lines.push("For subtasks, use sub-goal IDs from the Sub-Goal Dashboard above.");
+    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) {
@@ -1233,6 +1044,43 @@ proposalNudge = false) {
 // v2.5: checkpoint() removed — agent_declared milestones from
 // compression_checkpoint supersede the separate CheckpointSummary.
 // See buildRollingSummary() signal 1.
+/** v3.7.1: Derived Recovery Brief for the state-file Recent tier. Present
+ *  ONLY while a committed backtrack decision is the current round's record
+ *  (the recovery window); the redo commit replaces that record, so the
+ *  brief exits the projection by construction. Sources are the committed
+ *  rollback decision's own fields — no new persistence, no rejected
+ *  payloads. */
+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;
+}
 export function compileLoop(request, context) {
     const decision = levelDecision(request, context);
     const previous = getPreviousRound(request.loop_id, request.round - 1, context);
@@ -1285,7 +1133,6 @@ export function compileLoop(request, context) {
         lineage: [`${request.loop_id}:r${request.round}`],
         constraints_active: constraintLifecycle.active,
         constraints_retired: constraints.retired,
-        constraints_inactive: constraintLifecycle.inactive,
         constraint_metadata: constraintLifecycle.metadata,
         loop_id: request.loop_id,
         round: request.round,
@@ -1306,14 +1153,27 @@ export function compileLoop(request, context) {
         warnings,
     });
     const policy = getPolicy();
-    const statePath = `${policy.state_file.directory}/${request.loop_id}-state.md`;
+    // L7 (v3.7.x): the state-file path is empty when the file is disabled —
+    // prompts must never point at (or collapse content behind) a file that
+    // writeStateFile will not create. An empty path propagates into the
+    // assembler's pointer lines and the L1 collapse gate below.
+    const statePath = policy.state_file.enabled
+        ? `${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,
     });
-    const markdown = renderCanonicalStateMarkdown(state);
+    const markdown = renderCanonicalStateMarkdown(state, {
+        // v3.7.1: retry attempts are marked in the derived view (attempt is
+        // request context, not a committed fact). The Recovery Brief renders in
+        // the Recent tier only while a committed backtrack decision is this
+        // round's record; the redo commit removes it by construction.
+        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
@@ -1324,23 +1184,25 @@ export function compileLoop(request, context) {
     // 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";
+    // L7: pointer mode REQUIRES the file — with state_file disabled it would
+    // silently drop the full state from L2 prompts and point at nothing.
+    const l2Pointer = policy.state_file.enabled &&
+        policy.prompt.l2_pointer_enabled && decision.level === "l2";
     const artifact = assemblePromptArtifact({
         state,
         level: decision.level,
         reasons: decision.reasons,
-        mode: policy.prompt.injection_mode,
         budgets: {
             l0: policy.prompt.l0_max_chars,
             l1: policy.prompt.l1_max_chars,
             l2: adaptiveL2,
         },
         attempt: request.attempt,
-        selfEvaluationBlock: buildSelfEvalBlock(request.round, request.verification_flags, decision.level, 
+        selfEvaluationBlock: buildSelfEvalBlock(request.round, request.verification_flags, decision.level,
         // v3.4: restate the contract only when this prompt's Current Task IS
         // the ACTIVE contract (derived — not the previous submission's field,
         // which is a proposal and may differ from what this round executes).
-        activeContract != null, 
+        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 &&