loopforge 1.8.0 → 1.15.1

package/dist/loop-compiler.js

@@ -12,8 +12,8 @@
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { getPolicy } from "./policy.js";
-import { AgentStatus, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeRollingSummary, makeTaskAlignment, } from "./protocol.js";
-import { routeTechniqueAdaptive } from "./builder.js";
+import { AgentStatus, makeCheckpointSummary, makeLoopCompileResponse, makeLoopHealth, makeLoopObjective, makeRollingSummary, makeTaskAlignment, } from "./protocol.js";
+import { routeTechniqueAdaptive, SKILLS_DIR } from "./builder.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // Repair cue detection
 // ═══════════════════════════════════════════════════════════════════════════
@@ -224,8 +224,7 @@ export function getPreviousRound(loopId, roundNum, vaultContext) {
             return {
                 goal_id: lineage.goal_id ?? "",
                 goal_text_hash: lineage.goal_text_hash ?? "",
-                quality_score: lineage.quality_score ?? 0,
-                success: r.success ?? true,
+                success: r.success ?? lineage.success ?? true,
                 task: r.task ?? r.user_intent ?? "",
                 constraints_active: lineage.constraints_active ?? [],
                 prompt_text: r.full_prompt ?? "",
@@ -243,7 +242,7 @@ function getRecentRounds(loopId, n, vaultContext) {
         const lineage = (r.loop_lineage || r.lineage || {});
         if (lineage.loop_id === loopId) {
             rounds.push({
-                quality_score: lineage.quality_score ?? 0,
+                success: r.success ?? lineage.success ?? false,
                 round: lineage.round ?? 0,
                 goal_text_hash: lineage.goal_text_hash ?? "",
             });
@@ -252,6 +251,192 @@ function getRecentRounds(loopId, n, vaultContext) {
     rounds.sort((a, b) => b.round - a.round);
     return rounds.slice(0, n);
 }
+/** Extract the technique used in the most recent round before currentRound.
+ *  Scans vault entries for this loop_id and returns the technique_used field
+ *  from the highest round number below currentRound.
+ *  Returns null if no prior rounds exist (round 1 scenario). */
+function getPreviousTechnique(loopId, currentRound, vaultContext) {
+    if (vaultContext === null || currentRound <= 1)
+        return null;
+    const results = vaultContext.results || [];
+    if (!results.length)
+        return null;
+    let bestTechnique = null;
+    let bestRound = -1;
+    for (const r of results) {
+        const lineage = (r.loop_lineage || r.lineage || {});
+        if (lineage.loop_id !== loopId)
+            continue;
+        const rnd = lineage.round;
+        if (rnd >= currentRound || rnd <= bestRound)
+            continue;
+        // technique_used can be on the entry directly or in lineage
+        const technique = r.technique_used ??
+            lineage.technique_used ?? "";
+        if (technique) {
+            bestTechnique = technique;
+            bestRound = rnd;
+        }
+    }
+    return bestTechnique;
+}
+function techniqueChanged(loopId, newTechnique, currentRound, vaultContext) {
+    if (currentRound === 1)
+        return true; // Round 1: first selection is always a "change"
+    const prevTech = getPreviousTechnique(loopId, currentRound, vaultContext);
+    if (!prevTech)
+        return true; // No prior technique found → treat as change
+    return newTechnique !== prevTech;
+}
+/** Returns the mandatory state file read instruction that goes at the top
+ *  of every compiled prompt. Tells the agent to read the loop state file
+ *  before executing the round. */
+function renderStateFilePointer(loopId) {
+    return [
+        `⚠️ **BEFORE anything else**: Read \`.loopforge/state/${loopId}-state.md\``,
+        "for accumulated loop state — objective, constraints, progress, and cross-round summary.",
+        "This file is rewritten each round and is the single source of truth for loop state.",
+        "",
+    ].join("\n");
+}
+/** Render the full loop state file as markdown. Called by compileL2() every round.
+ *  The file is a snapshot — rewritten in full each round, not appended.
+ *  All sections have hard size caps from policy to prevent bloat.
+ *
+ *  Sections: Loop Objective, Progress, Cross-Round Summary, Active Constraints,
+ *  Checkpoints, Delegation Summary. */
+function renderStateFile(params) {
+    const lines = [];
+    const sfPolicy = getPolicy().state_file;
+    // ── Header ──
+    lines.push(`# LoopForge State — ${params.loopId}`);
+    lines.push("");
+    lines.push(`**Round**: ${params.currentRound}/${params.maxRounds}`);
+    lines.push("");
+    // ── Loop Objective ──
+    if (params.loopObjective) {
+        const lo = params.loopObjective;
+        lines.push("## Loop Objective");
+        if (lo.version && lo.version > 1) {
+            lines.push(`> Version ${lo.version}, created at Round ${lo.created_at_round}`);
+        }
+        lines.push("");
+        lines.push(`**Objective**: ${lo.objective}`);
+        lines.push("");
+        if (lo.success_criteria.length) {
+            lines.push("### Success Criteria");
+            for (const sc of lo.success_criteria) {
+                // Check if this criterion has been met (from execution_evidence)
+                lines.push(`- ${sc}`);
+            }
+            lines.push("");
+        }
+        if (lo.hard_constraints.length) {
+            lines.push("### Hard Constraints");
+            for (const hc of lo.hard_constraints) {
+                lines.push(`- ${hc}`);
+            }
+            lines.push("");
+        }
+    }
+    // ── Progress Dashboard ──
+    if (params.progressDashboard) {
+        lines.push(params.progressDashboard);
+        lines.push("");
+    }
+    // ── Cross-Round Summary ──
+    if (params.rollingSummary && params.rollingSummary.rounds_sampled > 0) {
+        const rs = params.rollingSummary;
+        const maxRounds = sfPolicy.max_summary_rounds;
+        lines.push(`## Cross-Round Summary (Last ${Math.min(rs.rounds_sampled, maxRounds)} Rounds)`);
+        lines.push("");
+        if (rs.key_outcomes.length) {
+            lines.push("**Key Outcomes**:");
+            for (const ko of rs.key_outcomes.slice(0, maxRounds)) {
+                lines.push(`- ${ko}`);
+            }
+            lines.push("");
+        }
+        if (rs.recurring_issues.length) {
+            lines.push("**Recurring Issues**:");
+            for (const ri of rs.recurring_issues) {
+                lines.push(`- ⚠️ ${ri}`);
+            }
+            lines.push("");
+        }
+        if (rs.failed_patterns && rs.failed_patterns.length) {
+            lines.push("**Failure Patterns**:");
+            for (const fp of rs.failed_patterns) {
+                lines.push(`- 🚫 ${fp}`);
+            }
+            lines.push("");
+        }
+    }
+    // ── Active Constraints ──
+    lines.push("## Active Constraints");
+    lines.push("");
+    if (params.constraints.length) {
+        for (const c of params.constraints) {
+            lines.push(`- ${c}`);
+        }
+    }
+    else {
+        lines.push("_(none)_");
+    }
+    lines.push("");
+    if (params.retiredConstraints.length) {
+        lines.push("## Retired Constraints");
+        lines.push("");
+        for (const c of params.retiredConstraints.slice(0, 10)) {
+            lines.push(`- ~${c}~`);
+        }
+        lines.push("");
+    }
+    // ── Checkpoints ──
+    if (params.checkpoints.length) {
+        const maxCp = sfPolicy.max_checkpoints;
+        const shown = params.checkpoints.slice(-maxCp).reverse(); // newest first
+        lines.push(`## Checkpoints (${shown.length})`);
+        lines.push("");
+        for (const cp of shown) {
+            lines.push(`### ${cp.label || `Round ${cp.declared_at_round}`}`);
+            lines.push(`> Declared at Round ${cp.declared_at_round}`);
+            lines.push("");
+            if (cp.outcome) {
+                lines.push(`**Outcome**: ${cp.outcome}`);
+                lines.push("");
+            }
+            if (cp.carried_constraints.length) {
+                lines.push("**Carried Constraints**:");
+                for (const cc of cp.carried_constraints) {
+                    lines.push(`- ${cc}`);
+                }
+                lines.push("");
+            }
+            if (cp.resolved_constraints.length) {
+                lines.push("**Resolved Constraints**:");
+                for (const rc of cp.resolved_constraints) {
+                    lines.push(`- ✅ ${rc}`);
+                }
+                lines.push("");
+            }
+        }
+    }
+    // ── Delegation Summary ──
+    if (params.delegationSummary) {
+        lines.push(params.delegationSummary);
+    }
+    // ── External Context (current round only) ──
+    if (params.externalContext) {
+        lines.push("---");
+        lines.push("");
+        lines.push("## External Context (This Round)");
+        lines.push("");
+        lines.push(params.externalContext);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
 function getPreviousRoundTask(loopId, roundNum, vaultContext) {
     const prev = getPreviousRound(loopId, roundNum, vaultContext);
     return prev?.task ?? "";
@@ -299,13 +484,6 @@ function countConsecutiveHashMismatches(loopId, vaultContext) {
 // ═══════════════════════════════════════════════════════════════════════════
 // Strategy collapse detection
 // ═══════════════════════════════════════════════════════════════════════════
-function strategyCollapse(loopId, vaultContext) {
-    const recent = getRecentRounds(loopId, 3, vaultContext);
-    if (recent.length < 3)
-        return false;
-    return recent.every((r) => r.quality_score < 3);
-}
-// ═══════════════════════════════════════════════════════════════════════════
 // Constraint Retirement (v3.5)
 // ═══════════════════════════════════════════════════════════════════════════
 function computeConstraintRetirement(activeConstraints, loopId, currentRound, vaultContext) {
@@ -412,7 +590,7 @@ function countProgressStallRounds(loopId, currentRound, vaultContext, threshold)
 }
 /** Detect repeated failure patterns in sampled rounds.
  *  A failure pattern = 2+ consecutive rounds where:
- *    1. quality_score < 3 (failed or weak)
+ *    1. success === false (failed)
  *    2. same technique was used
  *    3. task text is similar (Jaccard > 0.4)
  *
@@ -424,7 +602,7 @@ function detectFailurePatterns(sampled) {
     let runStart = -1;
     for (let i = 0; i < sampled.length; i++) {
         const r = sampled[i];
-        const isFailed = r.quality_score < 3;
+        const isFailed = r.success === false;
         if (isFailed && runStart === -1) {
             runStart = i;
         }
@@ -445,7 +623,7 @@ function detectFailurePatterns(sampled) {
     }
     return patterns;
 }
-/** Classify a run of consecutive low-quality rounds as a failure pattern.
+/** Classify a run of consecutive failed rounds as a failure pattern.
  *  Returns null if the rounds are too dissimilar to be the same pattern. */
 function classifyRun(run) {
     if (run.length < 2)
@@ -465,9 +643,9 @@ function classifyRun(run) {
     }
     const rounds = `R${run[0].round}-R${run[run.length - 1].round}`;
     const taskPreview = run[0].task.slice(0, 80);
-    const avgScore = (run.reduce((s, r) => s + r.quality_score, 0) / run.length).toFixed(1);
+    const failureRate = `${run.length}/${run.length}`;
     return (`technique '${technique}' on task '${taskPreview}' ` +
-        `failed ${run.length} consecutive rounds (${rounds}, avg score ${avgScore}) — ` +
+        `failed ${run.length} consecutive rounds (${rounds}) — ` +
         `consider strategy change`);
 }
 /** Extract round numbers referenced in failure pattern descriptions.
@@ -494,7 +672,7 @@ function extractFailureRoundNums(patterns) {
 // ═══════════════════════════════════════════════════════════════════════════
 // Rolling Summary (v3.5)
 // ═══════════════════════════════════════════════════════════════════════════
-export function buildRollingSummary(loopId, currentRound, vaultContext) {
+export function buildRollingSummary(loopId, currentRound, vaultContext, sinceRound) {
     if (vaultContext === null)
         return null;
     const results = vaultContext.results || [];
@@ -502,6 +680,7 @@ export function buildRollingSummary(loopId, currentRound, vaultContext) {
         return null;
     const policy = getPolicy();
     const window = policy.summary.window;
+    const minRound = sinceRound ?? 0;
     // Collect rounds matching this loop_id, excluding current
     const rounds = [];
     for (const r of results) {
@@ -511,9 +690,11 @@ export function buildRollingSummary(loopId, currentRound, vaultContext) {
         const rnd = lineage.round;
         if (rnd >= currentRound)
             continue;
+        if (rnd < minRound)
+            continue;
         rounds.push({
             round: rnd,
-            quality_score: lineage.quality_score ?? 0,
+            success: r.success ?? lineage.success ?? false,
             task: r.task ?? r.user_intent ?? "",
             output_summary: r.output_summary ?? "",
             constraint_violations: r.constraint_violations || [],
@@ -525,32 +706,13 @@ export function buildRollingSummary(loopId, currentRound, vaultContext) {
     // Sort by round descending, take last N
     rounds.sort((a, b) => b.round - a.round);
     const sampled = rounds.slice(0, window).reverse(); // chronological order
-    // Quality trajectory
-    const trajectory = sampled.map((r) => r.quality_score);
-    // Trajectory direction
-    let direction = "stable";
-    if (trajectory.length >= 2) {
-        const diffs = trajectory.slice(1).map((v, i) => v - trajectory[i]);
-        if (diffs.every((d) => d >= 0) && diffs.some((d) => d > 0)) {
-            direction = "improving";
-        }
-        else if (diffs.every((d) => d <= 0) && diffs.some((d) => d < 0)) {
-            direction = "declining";
-        }
-        else if (diffs.every((d) => d === 0)) {
-            direction = "stable";
-        }
-        else {
-            direction = "volatile";
-        }
-    }
-    // What worked
-    const whatWorked = [];
+    // v1.12: Key outcomes — all rounds with output_summary
+    const keyOutcomes = [];
     for (const r of sampled) {
-        if (r.quality_score >= 4 &&
-            r.output_summary) {
-            whatWorked.push(`R${r.round} (score=${r.quality_score}, ` +
-                `${r.technique_used || "n/a"}): ${String(r.output_summary).slice(0, 150)}`);
+        if (r.output_summary) {
+            const status = r.success ? "✓" : "✗";
+            keyOutcomes.push(`[R${r.round}] ${status} (${r.technique_used || "n/a"}): ` +
+                `${String(r.output_summary).slice(0, 200)}`);
         }
     }
     // Recurring issues
@@ -569,17 +731,10 @@ export function buildRollingSummary(loopId, currentRound, vaultContext) {
         .filter(([, count]) => count >= 2)
         .sort((a, b) => b[1] - a[1])
         .map(([v, count]) => `${v} (appeared in ${count} rounds)`);
-    // Key lessons
-    const keyLessons = [];
-    for (const r of sampled) {
-        if (r.quality_score >= 4 && r.output_summary) {
-            keyLessons.push(`[R${r.round}] ${String(r.output_summary).slice(0, 200)}`);
-        }
-    }
     // v1.7: Failure lineage weighting — detect and demote failure patterns
     const sampledRounds = sampled.map((r) => ({
         round: r.round,
-        quality_score: r.quality_score,
+        success: r.success,
         task: r.task,
         output_summary: r.output_summary,
         constraint_violations: r.constraint_violations,
@@ -587,21 +742,21 @@ export function buildRollingSummary(loopId, currentRound, vaultContext) {
     }));
     const failurePatterns = detectFailurePatterns(sampledRounds);
     const failedRoundNums = extractFailureRoundNums(failurePatterns);
-    // Re-weight key_lessons: lessons from failure-pattern rounds go to end
-    if (failedRoundNums.size > 0 && keyLessons.length > 0) {
+    // Re-weight key_outcomes: outcomes from failure-pattern rounds go to end
+    if (failedRoundNums.size > 0 && keyOutcomes.length > 0) {
         const promoted = [];
         const demoted = [];
-        for (const kl of keyLessons) {
-            const rndMatch = kl.match(/^\[R(\d+)\]/);
+        for (const ko of keyOutcomes) {
+            const rndMatch = ko.match(/^\[R(\d+)\]/);
             if (rndMatch && failedRoundNums.has(parseInt(rndMatch[1], 10))) {
-                demoted.push(kl.replace(/^\[R\d+\]/, "$& [Consider alternatives]"));
+                demoted.push(ko.replace(/^\[R\d+\]/, "$& [Consider alternatives]"));
             }
             else {
-                promoted.push(kl);
+                promoted.push(ko);
             }
         }
-        keyLessons.length = 0;
-        keyLessons.push(...promoted, ...demoted);
+        keyOutcomes.length = 0;
+        keyOutcomes.push(...promoted, ...demoted);
     }
     // Re-weight recurring_issues: mark issues that ONLY appear in failure-pattern rounds
     if (failedRoundNums.size > 0 && recurringIssues.length > 0) {
@@ -628,11 +783,8 @@ export function buildRollingSummary(loopId, currentRound, vaultContext) {
         }));
     }
     return makeRollingSummary({
-        quality_trajectory: trajectory,
-        trajectory_direction: direction,
-        what_worked: whatWorked,
+        key_outcomes: keyOutcomes,
         recurring_issues: recurringIssues,
-        key_lessons: keyLessons,
         rounds_sampled: sampled.length,
         generated_at_round: currentRound,
         failed_patterns: failurePatterns.length ? failurePatterns : [],
@@ -644,14 +796,13 @@ export function formatRollingSummaryForPrompt(rs) {
     const lines = [
         "### Cross-Round Summary (Accumulated)",
         "",
-        `**Sampled**: ${rs.rounds_sampled} prior rounds | **Direction**: ${rs.trajectory_direction}`,
-        `**Quality Trajectory**: [${rs.quality_trajectory.join(", ")}]`,
+        `**Sampled**: ${rs.rounds_sampled} prior rounds`,
         "",
     ];
-    if (rs.what_worked.length) {
-        lines.push("**What Worked (score >= 4)**:");
-        for (const w of rs.what_worked)
-            lines.push(`- ${w}`);
+    if (rs.key_outcomes.length) {
+        lines.push("**Key Outcomes**:");
+        for (const ko of rs.key_outcomes)
+            lines.push(`- ${ko}`);
         lines.push("");
     }
     if (rs.recurring_issues.length) {
@@ -665,21 +816,217 @@ export function formatRollingSummaryForPrompt(rs) {
         lines.push("### ⚠️ Failure Patterns — Consider Strategy Change");
         lines.push("");
         lines.push("The following approaches failed repeatedly. The compiler has demoted " +
-            "their influence on key lessons. Consider a different technique or " +
+            "their influence on key outcomes. Consider a different technique or " +
             "narrower scope.");
         for (const fp of rs.failed_patterns) {
             lines.push(`- 🚫 ${fp}`);
         }
         lines.push("");
     }
-    if (rs.key_lessons.length) {
-        lines.push("**Key Lessons From High-Score Rounds**:");
-        for (const kl of rs.key_lessons)
-            lines.push(`- ${kl}`);
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Checkpoint compression (v1.10 — subtask boundary snapshots)
+// ═══════════════════════════════════════════════════════════════════════════
+/** Build a CheckpointSummary from the current round's self-evaluation state.
+ *  Called when the Agent sets compression_checkpoint: true in its self-eval.
+ *  Snapshots the current constraints and outcome so they survive rolling-window
+ *  eviction in subsequent rounds. */
+export function buildCheckpointSummary(selfEval, round, activeConstraints, retiredConstraints) {
+    const policy = getPolicy();
+    const cpCfg = policy.checkpoint;
+    const maxCarried = cpCfg?.max_carried_constraints ?? 10;
+    const outcomeMaxChars = cpCfg?.outcome_max_chars ?? 200;
+    const label = selfEval.checkpoint_label?.trim() ||
+        `Subtask completed at round ${round}`;
+    const outcome = (selfEval.output_summary || "").trim().slice(0, outcomeMaxChars);
+    // Carried: constraints still active, capped
+    const carried = activeConstraints.slice(0, maxCarried);
+    // Resolved: constraints retired this round (retracted + the retire delta)
+    const resolved = retiredConstraints.slice(0, maxCarried);
+    return {
+        label,
+        declared_at_round: round,
+        outcome,
+        carried_constraints: carried,
+        resolved_constraints: resolved,
+    };
+}
+/** Format a CheckpointSummary as a prompt block.
+ *  Renders as a fixed section that persists across rolling-window eviction.
+ *  Returns empty string if the summary is null or has no meaningful data. */
+export function formatCheckpointForPrompt(cs) {
+    if (!cs)
+        return "";
+    // Must have at least a label and some content to be meaningful
+    if (!cs.label && !cs.outcome && !cs.carried_constraints.length)
+        return "";
+    const lines = [
+        `### Checkpoint: ${cs.label} (Round ${cs.declared_at_round})`,
+        "",
+    ];
+    if (cs.outcome) {
+        lines.push(`**Outcome**: ${cs.outcome}`);
+        lines.push("");
+    }
+    if (cs.carried_constraints.length) {
+        lines.push("**Carried Constraints** (still active):");
+        for (const c of cs.carried_constraints) {
+            lines.push(`- ${c}`);
+        }
+        lines.push("");
+    }
+    if (cs.resolved_constraints.length) {
+        lines.push("**Resolved Constraints** (closed with this checkpoint):");
+        for (const c of cs.resolved_constraints) {
+            lines.push(`- ${c}`);
+        }
         lines.push("");
     }
     return lines.join("\n");
 }
+/** Query the vault for the most recent checkpoint entry before the current
+ *  round. Returns null if no checkpoint has been declared yet. */
+function loadLatestCheckpoint(loopId, currentRound, vaultContext) {
+    if (!vaultContext)
+        return null;
+    const results = vaultContext.results || [];
+    let latest = null;
+    let latestRound = -1;
+    for (const r of results) {
+        const lineage = (r.loop_lineage || r.lineage || {});
+        if (lineage.loop_id !== loopId)
+            continue;
+        const rnd = lineage.round;
+        if (rnd >= currentRound)
+            continue;
+        // Check for stored checkpoint summary on this entry
+        const cp = r.checkpoint_summary;
+        if (cp && typeof cp.declared_at_round === "number" && cp.declared_at_round > latestRound) {
+            latest = cp;
+            latestRound = cp.declared_at_round;
+        }
+    }
+    if (!latest)
+        return null;
+    return makeCheckpointSummary({
+        label: latest.label ?? "",
+        declared_at_round: latest.declared_at_round ?? 0,
+        outcome: latest.outcome ?? "",
+        carried_constraints: latest.carried_constraints ?? [],
+        resolved_constraints: latest.resolved_constraints ?? [],
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Shared state evolution (P0/P1/P5) — used by both compileL1 and compileL2
+// ═══════════════════════════════════════════════════════════════════════════
+/** Apply P1 objective refinement from last round's self-evaluation.
+ *  Appends the refinement to the objective with a round marker.
+ *  Returns the updated loop objective (or unchanged if no refinement). */
+function applyObjectiveRefinement(loopObjective, lastRoundResult, currentRound) {
+    if (!loopObjective || !lastRoundResult?.objective_refinement)
+        return loopObjective;
+    const refinement = lastRoundResult.objective_refinement.trim();
+    if (!refinement)
+        return loopObjective;
+    const version = (loopObjective.version ?? 1) + 1;
+    const history = [...(loopObjective.refinement_history ?? []), refinement];
+    const policy = getPolicy();
+    const maxVersions = policy.evolution?.max_objective_versions ?? 10;
+    const prunedHistory = history.slice(-maxVersions);
+    const refinedObjective = `${loopObjective.objective} [R${currentRound}: ${refinement}]`;
+    return makeLoopObjective({
+        ...loopObjective,
+        objective: refinedObjective,
+        version,
+        refinement_history: prunedHistory,
+    });
+}
+/** Apply P0 discovered constraints and P5 retractions/revisions.
+ *  Pure function — returns updated constraints, loop objective, and retired list. */
+function applyConstraintEvolution(constraints, loopObjective, lastRoundResult, currentRound) {
+    const retired = [];
+    let lo = loopObjective;
+    let cs = [...constraints];
+    // P0: Merge discovered constraints
+    if (lastRoundResult?.discovered_constraints?.length) {
+        const policy = getPolicy();
+        const maxPerRound = policy.evolution?.max_discovered_constraints_per_round ?? 5;
+        const maxActive = policy.evolution?.max_active_constraints ?? 15;
+        const newConstraints = lastRoundResult.discovered_constraints
+            .slice(0, maxPerRound)
+            .filter((c) => !cs.includes(c));
+        cs = [...cs, ...newConstraints].slice(0, maxActive);
+    }
+    // P5a: Retracted constraints
+    if (lastRoundResult?.retracted_constraints?.length) {
+        for (const rc of lastRoundResult.retracted_constraints) {
+            const idx = cs.indexOf(rc);
+            if (idx >= 0) {
+                cs.splice(idx, 1);
+                retired.push(`[agent-retracted] ${rc}`);
+            }
+        }
+    }
+    // P5b: Revised success criteria
+    if (lastRoundResult?.revised_success_criteria?.length && lo) {
+        const sc = [...lo.success_criteria];
+        for (const rev of lastRoundResult.revised_success_criteria) {
+            const idx = sc.indexOf(rev.old);
+            if (idx >= 0)
+                sc[idx] = rev.new;
+            else
+                sc.push(rev.new);
+        }
+        const version = (lo.version ?? 1) + 1;
+        const history = [
+            ...(lo.refinement_history ?? []),
+            `R${currentRound}: revised ${lastRoundResult.revised_success_criteria.length} success criteria`,
+        ];
+        const updatedLo = makeLoopObjective({
+            ...lo,
+            success_criteria: sc,
+            version,
+            refinement_history: history,
+        });
+        // Rebuild constraints to include revised criteria, deduplicate
+        cs = [...new Set([
+                ...cs.filter((c) => !updatedLo.hard_constraints.includes(c) && !updatedLo.success_criteria.includes(c)),
+                ...updatedLo.hard_constraints,
+                ...updatedLo.success_criteria,
+            ])];
+        lo = updatedLo;
+    }
+    return { constraints: cs, loopObjective: lo, retired };
+}
+/** Collect checkpoint summaries from vault entries for a given loop.
+ *  Shared between compileL1 and compileL2 — same vault scanning logic. */
+function collectVaultCheckpoints(vaultContext, loopId, excludeRounds) {
+    const checkpoints = [];
+    if (!vaultContext)
+        return checkpoints;
+    const results = vaultContext.results || [];
+    for (const r of results) {
+        const lineage = (r.loop_lineage || r.lineage || {});
+        if (lineage.loop_id !== loopId)
+            continue;
+        const cp = r.checkpoint_summary;
+        if (cp && typeof cp.declared_at_round === "number") {
+            if (excludeRounds?.has(cp.declared_at_round))
+                continue;
+            if (checkpoints.some((c) => c.declared_at_round === cp.declared_at_round))
+                continue;
+            checkpoints.push(makeCheckpointSummary({
+                label: cp.label ?? "",
+                declared_at_round: cp.declared_at_round,
+                outcome: cp.outcome ?? "",
+                carried_constraints: cp.carried_constraints ?? [],
+                resolved_constraints: cp.resolved_constraints ?? [],
+            }));
+        }
+    }
+    return checkpoints;
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // External Context formatting (v1.7 — memory system integration)
 // ═══════════════════════════════════════════════════════════════════════════
@@ -721,43 +1068,35 @@ export function decideLevel(request, vaultContext) {
             return request.force_level;
         }
     }
-    // Gate 2: First call or explicit plan input → full rebuild
-    if (request.round === 1 || request.plan_source) {
+    // ── L2 triggers: structural restarts ──────────────────────────────────
+    // Gate 2: First call or explicit plan → full rebuild
+    if (request.round === 1 || request.plan_source)
         return "l2";
-    }
-    // Derive goal_id
+    // Gate 3: Checkpoint boundary — subtask completed, re-plan
+    if (request.last_round_result?.compression_checkpoint === true)
+        return "l2";
+    // Gate 4: goal_id stability
     const goalId = deriveGoalId(request.loop_id, request.task, request.goal_id);
     const prev = getPreviousRound(request.loop_id, request.round - 1, vaultContext);
     if (prev === null)
         return "l2";
-    // Gate 3: goal_id stability
     if (goalId !== prev.goal_id)
         return "l2";
-    // Gate 4: P0–P5 cognitive evolution signals → full recompile (v1.7)
-    // Check BEFORE the simple repair/new-constraint gates because evolution signals
-    // (constraint discovery, objective refinement, self-correction) need full L2
-    // processing. Only structural evolution signals trigger L2 — execution_evidence
-    // alone does not (it is processed via the rolling summary at L1).
-    if (request.last_round_result) {
-        const lr = request.last_round_result;
-        if ((lr.discovered_constraints?.length ?? 0) > 0 ||
-            (lr.objective_refinement?.trim().length ?? 0) > 0 ||
-            (lr.emerged_subtasks?.length ?? 0) > 0 ||
-            (lr.retracted_constraints?.length ?? 0) > 0 ||
-            (lr.revised_success_criteria?.length ?? 0) > 0 ||
-            (lr.wrong_assumptions?.length ?? 0) > 0) {
-            return "l2";
-        }
-    }
-    // Gate 5: Explicit failures or new constraints → patch
-    const hasNewConstraints = request.constraints_from_plan.length > 0;
-    const hasNewFailures = request.last_round_result !== null &&
-        !request.last_round_result.success;
-    const hasRepair = detectsRepairSignal(request);
-    if (hasNewConstraints || hasNewFailures || hasRepair)
-        return "l1";
-    // Nothing triggered → fast path
-    return "l0";
+    // ── L0 trigger: honest failure with no new information ────────────────
+    const lr = request.last_round_result;
+    const prevFailed = lr !== null && !lr.success;
+    const hasNoNewInfo = (lr?.discovered_constraints?.length ?? 0) === 0 &&
+        (lr?.objective_refinement?.trim().length ?? 0) === 0 &&
+        (lr?.emerged_subtasks?.length ?? 0) === 0 &&
+        (lr?.retracted_constraints?.length ?? 0) === 0 &&
+        (lr?.revised_success_criteria?.length ?? 0) === 0 &&
+        (lr?.wrong_assumptions?.length ?? 0) === 0 &&
+        request.constraints_from_plan.length === 0 &&
+        !detectsRepairSignal(request);
+    if (prevFailed && hasNoNewInfo)
+        return "l0";
+    // ── L1: default path — all P0-P5 state changes handled here ───────────
+    return "l1";
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // LAYER 2 — Soft Advisories (NEVER change compile level)
@@ -853,7 +1192,7 @@ export function checkLoopHealth(loopId, request, vaultContext) {
     // 4. strategy_stability
     const recent = getRecentRounds(loopId, 3, vaultContext);
     const strategyStability = recent.length > 0
-        ? recent.every((r) => r.quality_score >= 4)
+        ? recent.every((r) => r.success === true)
         : true;
     // 5. task_continuity
     let taskContinuity = 1.0;
@@ -890,15 +1229,22 @@ function computeSuggestedNextTask(loopId, vaultContext) {
     if (vaultContext === null)
         return "";
     const results = vaultContext.results || [];
+    let bestTask = "";
+    let bestRound = -1;
     for (const r of results) {
         const lineage = (r.loop_lineage || r.lineage || {});
-        if (lineage.loop_id === loopId) {
+        if (lineage.loop_id !== loopId)
+            continue;
+        const rnd = lineage.round ?? 0;
+        if (rnd > bestRound) {
             const task = r.task ?? r.user_intent ?? "";
-            if (task)
-                return `Previous round focused on: ${task.slice(0, 120)}`;
+            if (task) {
+                bestTask = task;
+                bestRound = rnd;
+            }
         }
     }
-    return "";
+    return bestTask ? `[R${bestRound}] Previous task: ${bestTask.slice(0, 120)}` : "";
 }
 export function computeAdvisories(request, vaultContext) {
     const warnings = [];
@@ -912,11 +1258,6 @@ export function computeAdvisories(request, vaultContext) {
         warnings.push(`goal_text_hash changed (${prev.goal_text_hash} → ${currentHash}) ` +
             "but goal_id matched — wording drift detected");
     }
-    // Strategy collapse check
-    if (strategyCollapse(request.loop_id, vaultContext)) {
-        warnings.push("strategy_collapse: 3 consecutive low-quality rounds — " +
-            "consider force_level=L2 rebuild");
-    }
     // Repair cue detection
     if (detectsRepairSignal(request)) {
         warnings.push("repair signal detected — L1 patch applied");
@@ -1105,6 +1446,96 @@ function computeLoopObjectiveFromTask(request, _vaultContext) {
     });
 }
 // ═══════════════════════════════════════════════════════════════════════════
+// P4: Shared consistency checks and progress dashboard (used by L1 & L2)
+// ═══════════════════════════════════════════════════════════════════════════
+/** Run P4 consistency validation checks on agent execution evidence.
+ *  Returns warning strings. Called by both compileL1 and compileL2.
+ *  Three checks:
+ *    1. Agent claims file changes but files_changed is empty
+ *    2. Agent reports success but test results show failures
+ *    3. Progress estimate mismatch (objective vs subjective) */
+function runP4ConsistencyChecks(evidence, outputSummary, success, loopObjective) {
+    const warnings = [];
+    // Check 1: Agent claims action but reports no files changed
+    if (evidence.files_changed.length === 0 && outputSummary) {
+        const actionWords = /\b(fix|modif|chang|updat|refactor|implement|add|remov|delet|rewrit|修补|修改|更改|更新|重构|实现|添加|删除|重写)\b/i;
+        if (actionWords.test(outputSummary)) {
+            warnings.push("P4: Agent output claims changes but execution_evidence.files_changed is empty — possible oversight");
+        }
+    }
+    // Check 2: Agent reports success but tests failed
+    if (evidence.test_results && evidence.test_results.failed > 0 && success) {
+        warnings.push(`P4: Agent reports success=true but ${evidence.test_results.failed} tests failed — claims may not match reality`);
+    }
+    // Check 3: Progress estimate mismatch with criteria tracking
+    if (loopObjective && loopObjective.success_criteria.length > 0) {
+        const metCount = evidence.success_criteria_met.length;
+        const totalCount = loopObjective.success_criteria.length;
+        const objectiveProgress = totalCount > 0 ? metCount / totalCount : 0;
+        const subjectiveProgress = evidence.progress_estimate;
+        const policy = getPolicy();
+        const mismatchThreshold = policy.evolution?.progress_mismatch_threshold ?? 0.3;
+        if (Math.abs(objectiveProgress - subjectiveProgress) > mismatchThreshold) {
+            warnings.push(`P4: Progress estimate mismatch — agent estimates ${(subjectiveProgress * 100).toFixed(0)}% but ${metCount}/${totalCount} criteria met (${(objectiveProgress * 100).toFixed(0)}%)`);
+        }
+    }
+    return warnings;
+}
+/** Build a progress dashboard string for prompt or state file injection.
+ *  Used by both compileL1 and compileL2. When showTrend is true, also
+ *  computes a trend arrow from vault history (L2 path). */
+function buildProgressDashboard(evidence, loopObjective, vaultContext, loopId, currentRound, showTrend) {
+    const totalCriteria = loopObjective?.success_criteria.length ?? 0;
+    const metCriteria = evidence.success_criteria_met.length;
+    const remainingCriteria = evidence.success_criteria_remaining;
+    const objProgress = totalCriteria > 0 ? metCriteria / totalCriteria : evidence.progress_estimate;
+    const subjProgress = evidence.progress_estimate;
+    const lines = [
+        "",
+        "### Progress Dashboard",
+        "",
+        `**Overall**: ${metCriteria}/${totalCriteria} criteria met (${(objProgress * 100).toFixed(0)}%)`,
+    ];
+    if (Math.abs(objProgress - subjProgress) > 0.05) {
+        lines.push(`**Agent estimate**: ${(subjProgress * 100).toFixed(0)}%`);
+    }
+    if (evidence.files_changed.length) {
+        lines.push(`**Files changed**: ${evidence.files_changed.join(", ")}`);
+    }
+    if (evidence.test_results) {
+        const tr = evidence.test_results;
+        lines.push(`**Tests**: ${tr.passed} passed, ${tr.failed} failed, ${tr.skipped} skipped`);
+    }
+    if (remainingCriteria.length) {
+        lines.push("**Remaining criteria**:");
+        for (const rc of remainingCriteria.slice(0, 5)) {
+            lines.push(`- ${rc}`);
+        }
+        if (remainingCriteria.length > 5) {
+            lines.push(`- ... and ${remainingCriteria.length - 5} more`);
+        }
+    }
+    lines.push("");
+    // Trend arrow — only computed in L2 path where full vault history is available
+    if (showTrend && vaultContext && loopObjective) {
+        const prevEvidence = getPreviousRoundEvidence(loopId, currentRound - 1, vaultContext);
+        if (prevEvidence) {
+            const trend = objProgress - (prevEvidence.success_criteria_met.length / Math.max(totalCriteria, 1));
+            if (trend > 0.03) {
+                lines.push(`**Trend**: ↑ advancing (+${(trend * 100).toFixed(0)}% this round)`);
+            }
+            else if (trend > -0.03) {
+                lines.push("**Trend**: → stable");
+            }
+            else {
+                lines.push(`**Trend**: ↓ regressing (${(trend * 100).toFixed(0)}% this round)`);
+            }
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════════════════
 // Compilation — L0 / L1 / L2
 // ═══════════════════════════════════════════════════════════════════════════
 function compileL0(request, vaultContext, prevRound) {
@@ -1137,108 +1568,196 @@ function compileL0(request, vaultContext, prevRound) {
     return l2Response;
 }
 function compileL1(request, vaultContext, prevRound) {
-    const prev = prevRound ??
-        getPreviousRound(request.loop_id, request.round - 1, vaultContext);
     const goalId = deriveGoalId(request.loop_id, request.task, request.goal_id);
-    const newConstraints = [...request.constraints_from_plan];
-    let activeRaw = [...(prev?.constraints_active ?? []), ...newConstraints];
-    // Deduplicate preserving order
-    activeRaw = [...new Set(activeRaw)];
-    // v3.5: Constraint retirement
-    const { active, retired } = computeConstraintRetirement(activeRaw, request.loop_id, request.round, vaultContext);
-    // v3.5: Rolling summary
+    const lr = request.last_round_result;
+    // ── v1.14: Technique routing (Tier 1 only — 4 techniques) ────────────
+    // L1 is the default path: technique evolves within Tier 1 unless
+    // decideLevel already escalated to L2 (strategy collapse / checkpoint).
+    const analysis = routeTechniqueAdaptive(request.task, vaultContext, request.loop_id, 
+    /* isCheckpoint */ false);
+    const technique = analysis.technique;
+    const referenceFile = analysis.reference_file;
+    // Determine if technique changed from last round
+    const techChanged = techniqueChanged(request.loop_id, technique, request.round, vaultContext);
+    // ── Loop Objective: load from vault, apply P1 refinement ─────────────
+    let loopObjective = null;
+    const vaultLo = vaultGetLoopObjective(request.loop_id, vaultContext);
+    if (vaultLo) {
+        const loData = vaultLo.loop_objective;
+        if (loData) {
+            loopObjective = makeLoopObjective({
+                objective: loData.objective ?? "",
+                success_criteria: loData.success_criteria ?? [],
+                hard_constraints: loData.hard_constraints ?? [],
+                created_at_round: loData.created_at_round ?? 1,
+                loop_id: loData.loop_id ?? request.loop_id,
+                version: loData.version ?? 1,
+                refinement_history: loData.refinement_history ?? [],
+            });
+        }
+    }
+    if (!loopObjective && request.loop_objective) {
+        loopObjective = request.loop_objective;
+    }
+    // P1: Apply objective refinement (shared)
+    loopObjective = applyObjectiveRefinement(loopObjective, lr, request.round);
+    // ── Build active constraints (base + LO) ─────────────────────────────
+    let constraints = [...request.constraints_from_plan];
+    if (loopObjective) {
+        constraints = [
+            ...new Set([
+                ...constraints,
+                ...loopObjective.hard_constraints,
+                ...loopObjective.success_criteria,
+            ]),
+        ];
+    }
+    // ── P0/P5: Constraint evolution (shared) ─────────────────────────────
+    const { constraints: evolvedCs, loopObjective: evolvedLo, retired } = applyConstraintEvolution(constraints, loopObjective, lr, request.round);
+    constraints = evolvedCs;
+    loopObjective = evolvedLo;
+    // ── Constraint retirement ────────────────────────────────────────────
+    const { active, retired: autoRetired } = computeConstraintRetirement(constraints, request.loop_id, request.round, vaultContext);
+    for (const r of autoRetired) {
+        if (!retired.includes(r))
+            retired.push(r);
+    }
+    // ── Rolling summary + P5c wrong assumptions ──────────────────────────
     const rollingSummary = buildRollingSummary(request.loop_id, request.round, vaultContext);
+    if (lr?.wrong_assumptions?.length) {
+        if (rollingSummary) {
+            rollingSummary.key_outcomes = [
+                ...rollingSummary.key_outcomes,
+                ...lr.wrong_assumptions.map((a) => `Wrong assumption corrected: ${a}`),
+            ];
+        }
+    }
     const rollingText = formatRollingSummaryForPrompt(rollingSummary);
-    const violations = request.last_round_result?.constraint_violations ?? [];
-    const diffParts = [];
-    if (newConstraints.length) {
-        diffParts.push(`new constraints: [${newConstraints.join(", ")}]`);
+    // ── P2: Emerged subtasks → suggested next task ───────────────────────
+    let suggestedNextTask = "";
+    if (lr?.emerged_subtasks?.length) {
+        suggestedNextTask = lr.emerged_subtasks.slice(0, 3).join("; ");
     }
-    if (retired.length) {
-        diffParts.push(`retired constraints: [${retired.join(", ")}]`);
+    // ── P4: Consistency validation ───────────────────────────────────────
+    const evidence = lr?.execution_evidence;
+    const warnings = evidence
+        ? runP4ConsistencyChecks(evidence, lr.output_summary, lr.success, loopObjective)
+        : [];
+    // ── Route to specialist (all 4 techniques available via Tier 1) ──────
+    let prompt;
+    if (technique === "step-back") {
+        prompt = compileStepBack(request, goalId, active, loopObjective, rollingText, analysis, { embedSkeleton: techChanged, level: "l1" });
     }
-    if (violations.length) {
-        diffParts.push(`violations from last round: [${violations.join(", ")}]`);
+    else if (technique === "least-to-most") {
+        prompt = compileLeastToMost(request, goalId, active, loopObjective, rollingText, analysis, { embedSkeleton: techChanged, level: "l1" });
     }
-    if (request.new_since_last_round) {
-        diffParts.push(`delta: ${request.new_since_last_round.slice(0, 200)}`);
+    else if (technique === "tree-of-thought") {
+        prompt = compileToT(request, goalId, active, loopObjective, rollingText, analysis, { embedSkeleton: techChanged, level: "l1" });
     }
-    // Build patched prompt
-    const lines = [
-        `## Loop Round ${request.round} — L1 Patch`,
-        "",
-        `**Goal**: ${request.task}`,
-        `**Loop ID**: ${request.loop_id}`,
-        `**Goal ID**: ${goalId}`,
-        "",
-    ];
-    if (rollingText) {
-        lines.push(rollingText);
-        lines.push("");
+    else {
+        prompt = compileGeneric(request, goalId, active, loopObjective, rollingText, analysis, referenceFile, technique, { embedSkeleton: techChanged, level: "l1" });
     }
-    if (active.length) {
-        lines.push("### Active Constraints (inherited + new, pruned)");
-        for (const c of active)
-            lines.push(`- ${c}`);
-        lines.push("");
+    // ── P4: Progress Dashboard ───────────────────────────────────────────
+    const progressDashboard = (evidence && loopObjective)
+        ? buildProgressDashboard(evidence, loopObjective, vaultContext, request.loop_id, request.round, /* showTrend */ false)
+        : "";
+    // ── v1.14: Render state file ─────────────────────────────────────────
+    const sfPolicy = getPolicy().state_file;
+    let stateFileContent;
+    if (sfPolicy.enabled) {
+        const allCheckpoints = collectVaultCheckpoints(vaultContext, request.loop_id);
+        const delegationSummary = vaultContext
+            ? buildDelegationSummary(vaultContext)
+            : "";
+        stateFileContent = renderStateFile({
+            loopId: request.loop_id,
+            currentRound: request.round,
+            maxRounds: request.max_rounds ?? sfPolicy.max_summary_rounds * 2,
+            loopObjective,
+            rollingSummary,
+            constraints: active,
+            retiredConstraints: retired,
+            checkpoints: allCheckpoints,
+            delegationSummary,
+            progressDashboard,
+            externalContext: request.external_context,
+        });
+        prompt = renderStateFilePointer(request.loop_id) + "\n" + prompt;
+    }
+    // ── Build thin diff ──────────────────────────────────────────────────
+    const violations = lr?.constraint_violations ?? [];
+    const diffParts = [];
+    if (request.constraints_from_plan.length) {
+        diffParts.push(`new constraints: [${request.constraints_from_plan.join(", ")}]`);
     }
     if (retired.length) {
-        lines.push("### Retired Constraints (no recent activity)");
-        for (const c of retired)
-            lines.push(`- ~${c}~`);
-        lines.push("");
+        diffParts.push(`retired constraints: [${retired.join(", ")}]`);
     }
     if (violations.length) {
-        lines.push("### Violations From Last Round (must fix)");
-        for (const v of violations)
-            lines.push(`- ${v}`);
-        lines.push("");
+        diffParts.push(`violations: [${violations.join(", ")}]`);
     }
     if (request.new_since_last_round) {
-        lines.push("### What Changed Since Last Round");
-        lines.push(request.new_since_last_round);
-        lines.push("");
-    }
-    if (request.last_round_result?.output_summary) {
-        lines.push("### Last Round Summary");
-        lines.push(request.last_round_result.output_summary);
-        lines.push("");
+        diffParts.push(`delta: ${request.new_since_last_round.slice(0, 200)}`);
     }
-    lines.push("### Task");
-    lines.push(request.task);
+    // v1.14: When state file is enabled, progressDashboard lives in the state
+    // file (see renderStateFile above). Only inline it in the prompt when the
+    // state file is disabled — this keeps the prompt truly thin.
+    const finalPrompt = sfPolicy.enabled ? prompt : prompt + progressDashboard;
     return makeLoopCompileResponse({
         status: AgentStatus.OK,
-        prompt: lines.join("\n"),
+        prompt: finalPrompt,
         recompile_level: "l1",
-        diff_from_previous: diffParts.length ? diffParts.join("; ") : "Patch applied.",
+        diff_from_previous: diffParts.length ? diffParts.join("; ") : "L1 continue — state updated in file.",
         lineage: [`${request.loop_id}:r${request.round}`],
         constraints_active: active,
         constraints_retired: retired,
-        technique_used: "patch",
+        technique_used: technique,
+        reference_file: referenceFile,
         rolling_summary: rollingSummary,
         loop_id: request.loop_id,
         round: request.round,
         goal_id: goalId,
         goal_text_hash: computeGoalTextHash(request.task),
+        loop_objective: loopObjective,
         plan_source: request.plan_source,
-        warnings: [],
+        suggested_next_task: suggestedNextTask,
+        warnings,
+        state_file_content: stateFileContent,
     });
 }
 export function compileL2(request, vaultContext) {
     const goalId = deriveGoalId(request.loop_id, request.task, request.goal_id);
-    // v3.5: Adaptive technique routing
-    const analysis = routeTechniqueAdaptive(request.task, vaultContext, request.loop_id);
-    const technique = analysis.technique;
-    const referenceFile = analysis.reference_file;
-    // v3.5: Rolling summary
-    const rollingSummary = buildRollingSummary(request.loop_id, request.round, vaultContext);
+    // v1.15: L2 no longer auto-selects a technique. The Agent reads the technique
+    // catalog (skills/prompt-techniques/SKILL.md), freely chooses the best fit
+    // based on loop state, reads the corresponding reference file, and applies
+    // it directly to the task.
+    // v1.10: Checkpoint — load existing or build new from last round's self-eval
+    let checkpointSummary = null;
+    let checkpointRound = 0;
+    // Check if the last round declared a checkpoint
+    const lr = request.last_round_result;
+    if (lr?.compression_checkpoint === true) {
+        // Build fresh checkpoint from the last round's data
+        // Constraints haven't been updated yet at this point, but we snapshot the
+        // current state as seen by this compile call (pre-P5 correction).
+        // We defer building until constraints are finalized below.
+        checkpointRound = request.round - 1;
+    }
+    else if (request.round > 1) {
+        // No new checkpoint — try loading the previous one from vault
+        checkpointSummary = loadLatestCheckpoint(request.loop_id, request.round, vaultContext);
+        if (checkpointSummary) {
+            checkpointRound = checkpointSummary.declared_at_round;
+        }
+    }
+    // v3.5: Rolling summary — optionally scoped to post-checkpoint rounds
+    const rollingSummary = buildRollingSummary(request.loop_id, request.round, vaultContext, checkpointRound > 0 ? checkpointRound : undefined);
     // P5c: Wrong assumptions — must be applied BEFORE formatting so they appear
     // in the rendered cross-round summary text injected into the prompt.
-    const lr = request.last_round_result;
     if (lr?.wrong_assumptions?.length) {
         if (rollingSummary) {
-            rollingSummary.key_lessons = [
-                ...rollingSummary.key_lessons,
+            rollingSummary.key_outcomes = [
+                ...rollingSummary.key_outcomes,
                 ...lr.wrong_assumptions.map((a) => `Wrong assumption corrected: ${a}`),
             ];
         }
@@ -1275,26 +1794,9 @@ export function compileL2(request, vaultContext) {
             loopObjective = request.loop_objective;
         }
     }
-    // ── P1: Apply objective_refinement from last round ──
-    if (loopObjective && request.last_round_result?.objective_refinement) {
-        const refinement = request.last_round_result.objective_refinement.trim();
-        if (refinement) {
-            const version = (loopObjective.version ?? 1) + 1;
-            const history = [...(loopObjective.refinement_history ?? []), refinement];
-            // Enforce max versions from policy
-            const policy = getPolicy();
-            const maxVersions = policy.evolution?.max_objective_versions ?? 10;
-            const prunedHistory = history.slice(-maxVersions);
-            const refinedObjective = `${loopObjective.objective} [R${request.round}: ${refinement}]`;
-            loopObjective = makeLoopObjective({
-                ...loopObjective,
-                objective: refinedObjective,
-                version,
-                refinement_history: prunedHistory,
-            });
-        }
-    }
-    // ── Build active constraints (base + LO + P0 discovered) ──
+    // ── P1: Apply objective refinement (shared) ──
+    loopObjective = applyObjectiveRefinement(loopObjective, lr, request.round);
+    // ── Build active constraints (base + LO) ──
     let constraints = [...request.constraints_from_plan];
     if (loopObjective) {
         constraints = [
@@ -1305,76 +1807,39 @@ export function compileL2(request, vaultContext) {
             ]),
         ];
     }
-    // P0: Merge discovered constraints from last round
-    if (request.last_round_result?.discovered_constraints?.length) {
-        const policy = getPolicy();
-        const maxPerRound = policy.evolution?.max_discovered_constraints_per_round ?? 5;
-        const maxActive = policy.evolution?.max_active_constraints ?? 15;
-        const newConstraints = request.last_round_result.discovered_constraints
-            .slice(0, maxPerRound)
-            .filter((c) => !constraints.includes(c));
-        constraints = [...constraints, ...newConstraints].slice(0, maxActive);
-    }
     // ═══════════════════════════════════════════════════════════════════════════
-    // P5: Self-correction — MUST process retractions/revisions BEFORE prompt build
-    // so the technician compiler sees the corrected constraints and loop objective.
+    // P0/P5: Constraint evolution (shared) — retractions/revisions BEFORE prompt
     // ═══════════════════════════════════════════════════════════════════════════
     const warnings = [];
-    const retired = [];
-    // P5a: Retracted constraints — remove from active set
-    if (lr?.retracted_constraints?.length) {
-        for (const rc of lr.retracted_constraints) {
-            const idx = constraints.indexOf(rc);
-            if (idx >= 0) {
-                constraints.splice(idx, 1);
-                retired.push(`[agent-retracted] ${rc}`);
-            }
-        }
-    }
-    // P5b: Revised success criteria — update Loop Objective
-    if (lr?.revised_success_criteria?.length && loopObjective) {
-        const sc = [...loopObjective.success_criteria];
-        for (const rev of lr.revised_success_criteria) {
-            const idx = sc.indexOf(rev.old);
-            if (idx >= 0) {
-                sc[idx] = rev.new;
-            }
-            else {
-                sc.push(rev.new);
-            }
-        }
-        const version = (loopObjective.version ?? 1) + 1;
-        const history = [
-            ...(loopObjective.refinement_history ?? []),
-            `R${request.round}: revised ${lr.revised_success_criteria.length} success criteria`,
-        ];
-        const updatedLo = makeLoopObjective({
-            ...loopObjective,
-            success_criteria: sc,
-            version,
-            refinement_history: history,
-        });
-        // Rebuild constraints to include revised criteria
-        constraints = [...new Set([
-                ...constraints.filter((c) => !updatedLo.hard_constraints.includes(c) && !updatedLo.success_criteria.includes(c)),
-                ...updatedLo.hard_constraints,
-                ...updatedLo.success_criteria,
-            ])];
-        loopObjective = updatedLo;
-    }
-    // ── Route to technique-specific specialist (v1.1 deep integration) ──
-    let prompt;
-    if (technique === "step-back") {
-        prompt = compileStepBack(request, goalId, constraints, loopObjective, rollingText, analysis);
-    }
-    else if (technique === "least-to-most") {
-        prompt = compileLeastToMost(request, goalId, constraints, loopObjective, rollingText, analysis);
-    }
-    else if (technique === "tree-of-thought") {
-        prompt = compileToT(request, goalId, constraints, loopObjective, rollingText, analysis);
-    }
-    else {
-        prompt = compileGeneric(request, goalId, constraints, loopObjective, rollingText, analysis, referenceFile, technique);
+    const evoResult = applyConstraintEvolution(constraints, loopObjective, lr, request.round);
+    constraints = evoResult.constraints;
+    loopObjective = evoResult.loopObjective;
+    const retired = evoResult.retired;
+    // ── v1.10: Build checkpoint summary if last round declared one ──
+    if (checkpointRound > 0 && !checkpointSummary && lr) {
+        // checkpointRound was set but no summary yet → fresh declaration
+        // We need the self-eval from last round. It's embedded in lr fields.
+        // Build a synthetic SelfEvaluation from the last_round_result for the builder.
+        const synthEval = {
+            success: lr.success,
+            output_summary: lr.output_summary,
+            constraint_violations: lr.constraint_violations,
+            should_continue: true,
+            compression_checkpoint: true,
+            checkpoint_label: lr.checkpoint_label ?? "",
+        };
+        checkpointSummary = buildCheckpointSummary(synthEval, checkpointRound, constraints, retired);
+    }
+    // ── v1.15: Build L2 prompt with Technique Selection block ──
+    // The Agent freely chooses a technique by reading the catalog and reference
+    // files. LoopForge provides the loop state (objective, constraints, rolling
+    // summary) — the Agent provides the reasoning strategy.
+    let prompt = buildL2Prompt(request, goalId, constraints, loopObjective, rollingText);
+    // ── v1.10: Inject checkpoint block (before rolling summary in prompt) ──
+    // The checkpoint is rendered before the external context so it appears
+    // in a natural position: after Loop Objective, before Cross-Round Summary.
+    if (checkpointSummary) {
+        prompt += "\n" + formatCheckpointForPrompt(checkpointSummary);
     }
     // ── v1.7: Inject external memory context (L2 only) ──
     const policy = getPolicy();
@@ -1393,29 +1858,7 @@ export function compileL2(request, vaultContext) {
     // ═══════════════════════════════════════════════════════════════════════════
     const evidence = lr?.execution_evidence;
     if (evidence) {
-        // Check 1: Agent claims action but reports no files changed
-        if (evidence.files_changed.length === 0 && lr.output_summary) {
-            const actionWords = /\b(fix|modif|chang|updat|refactor|implement|add|remov|delet|rewrit|修补|修改|更改|更新|重构|实现|添加|删除|重写)\b/i;
-            if (actionWords.test(lr.output_summary)) {
-                warnings.push("P4: Agent output claims changes but execution_evidence.files_changed is empty — possible oversight");
-            }
-        }
-        // Check 2: Agent reports success but tests failed
-        if (evidence.test_results && evidence.test_results.failed > 0 && lr.success) {
-            warnings.push(`P4: Agent reports success=true but ${evidence.test_results.failed} tests failed — claims may not match reality`);
-        }
-        // Check 3: Progress estimate mismatch with criteria tracking
-        if (loopObjective && loopObjective.success_criteria.length > 0) {
-            const metCount = evidence.success_criteria_met.length;
-            const totalCount = loopObjective.success_criteria.length;
-            const objectiveProgress = totalCount > 0 ? metCount / totalCount : 0;
-            const subjectiveProgress = evidence.progress_estimate;
-            const policy = getPolicy();
-            const mismatchThreshold = policy.evolution?.progress_mismatch_threshold ?? 0.3;
-            if (Math.abs(objectiveProgress - subjectiveProgress) > mismatchThreshold) {
-                warnings.push(`P4: Progress estimate mismatch — agent estimates ${(subjectiveProgress * 100).toFixed(0)}% but ${metCount}/${totalCount} criteria met (${(objectiveProgress * 100).toFixed(0)}%)`);
-            }
-        }
+        warnings.push(...runP4ConsistencyChecks(evidence, lr.output_summary, lr.success, loopObjective));
     }
     // ═══════════════════════════════════════════════════════════════════════════
     // P4: Progress gradient — early stall detection
@@ -1439,71 +1882,58 @@ export function compileL2(request, vaultContext) {
     // ═══════════════════════════════════════════════════════════════════════════
     // P4: Build Progress Dashboard for prompt injection
     // ═══════════════════════════════════════════════════════════════════════════
-    let progressDashboard = "";
-    if (evidence && loopObjective) {
-        const totalCriteria = loopObjective.success_criteria.length;
-        const metCriteria = evidence.success_criteria_met.length;
-        const remainingCriteria = evidence.success_criteria_remaining;
-        const objProgress = totalCriteria > 0 ? metCriteria / totalCriteria : evidence.progress_estimate;
-        const subjProgress = evidence.progress_estimate;
-        const lines = [
-            "",
-            "### Progress Dashboard",
-            "",
-            `**Overall**: ${metCriteria}/${totalCriteria} criteria met (${(objProgress * 100).toFixed(0)}%)`,
-        ];
-        if (Math.abs(objProgress - subjProgress) > 0.05) {
-            lines.push(`**Agent estimate**: ${(subjProgress * 100).toFixed(0)}%`);
-        }
-        if (evidence.files_changed.length) {
-            lines.push(`**Files changed**: ${evidence.files_changed.join(", ")}`);
-        }
-        if (evidence.test_results) {
-            const tr = evidence.test_results;
-            lines.push(`**Tests**: ${tr.passed} passed, ${tr.failed} failed, ${tr.skipped} skipped`);
-        }
-        if (remainingCriteria.length) {
-            lines.push("**Remaining criteria**:");
-            for (const rc of remainingCriteria.slice(0, 5)) {
-                lines.push(`- ${rc}`);
-            }
-            if (remainingCriteria.length > 5) {
-                lines.push(`- ... and ${remainingCriteria.length - 5} more`);
-            }
-        }
-        lines.push("");
-        // Compute trend from previous round
-        if (vaultContext) {
-            const prevEvidence = getPreviousRoundEvidence(request.loop_id, request.round - 1, vaultContext);
-            if (prevEvidence) {
-                const trend = objProgress - (prevEvidence.success_criteria_met.length / Math.max(totalCriteria, 1));
-                if (trend > 0.03) {
-                    lines.push(`**Trend**: ↑ advancing (+${(trend * 100).toFixed(0)}% this round)`);
-                }
-                else if (trend > -0.03) {
-                    lines.push("**Trend**: → stable");
-                }
-                else {
-                    lines.push(`**Trend**: ↓ regressing (${(trend * 100).toFixed(0)}% this round)`);
-                }
-                lines.push("");
-            }
-        }
-        progressDashboard = lines.join("\n");
+    const progressDashboard = (evidence && loopObjective)
+        ? buildProgressDashboard(evidence, loopObjective, vaultContext, request.loop_id, request.round, /* showTrend */ true)
+        : "";
+    // ── v1.14: Render state file ──────────────────────────────────────────
+    // Collect all accumulated state and render it as a markdown snapshot.
+    // The caller writes this to .loopforge/state/{loopId}-state.md.
+    const sfPolicy = getPolicy().state_file;
+    let stateFileContent;
+    if (sfPolicy.enabled) {
+        const excludeRounds = checkpointSummary
+            ? new Set([checkpointSummary.declared_at_round])
+            : undefined;
+        const allCheckpoints = collectVaultCheckpoints(vaultContext, request.loop_id, excludeRounds);
+        if (checkpointSummary)
+            allCheckpoints.unshift(checkpointSummary);
+        const delegationSummary = vaultContext
+            ? buildDelegationSummary(vaultContext)
+            : "";
+        stateFileContent = renderStateFile({
+            loopId: request.loop_id,
+            currentRound: request.round,
+            maxRounds: request.max_rounds ?? sfPolicy.max_summary_rounds * 2,
+            loopObjective,
+            rollingSummary,
+            constraints,
+            retiredConstraints: retired,
+            checkpoints: allCheckpoints,
+            delegationSummary,
+            progressDashboard,
+            externalContext: request.external_context,
+        });
+        // Prepend state file pointer to the prompt
+        prompt = renderStateFilePointer(request.loop_id) + "\n" + prompt;
     }
+    // v1.14: When state file is enabled, progressDashboard lives in the state
+    // file (see renderStateFile above). Only inline it in the prompt when the
+    // state file is disabled — this keeps the prompt truly thin.
+    const finalPrompt = sfPolicy.enabled ? prompt : prompt + progressDashboard;
     return makeLoopCompileResponse({
         status: AgentStatus.OK,
-        prompt: prompt + progressDashboard,
+        prompt: finalPrompt,
         recompile_level: "l2",
         diff_from_previous: request.round === 1 || request.plan_source
             ? "Full recompile — new goal or first call."
-            : "Full recompile — goal_id changed or strategy collapse.",
+            : "Full recompile — goal_id changed or checkpoint boundary.",
         lineage: [`${request.loop_id}:r${request.round}`],
         constraints_active: constraints,
         constraints_retired: retired,
-        technique_used: technique,
-        reference_file: referenceFile,
+        technique_used: "agent-selected",
+        reference_file: `${SKILLS_DIR}/prompt-techniques/SKILL.md`,
         rolling_summary: rollingSummary,
+        checkpoint_summary: checkpointSummary,
         loop_id: request.loop_id,
         round: request.round,
         goal_id: goalId,
@@ -1512,11 +1942,51 @@ export function compileL2(request, vaultContext) {
         plan_source: request.plan_source,
         suggested_next_task: suggestedNextTask,
         warnings,
+        state_file_content: stateFileContent,
     });
 }
+// ═══════════════════════════════════════════════════════════════════════════
+// L2 Prompt Builder (v1.15 — Agent technique autonomy)
+// ═══════════════════════════════════════════════════════════════════════════
+/** Build the L2 restart prompt with a Technique Selection block.
+ *  The Agent reads the technique catalog (SKILL.md), freely chooses the best
+ *  technique based on loop state, reads the corresponding reference file, and
+ *  applies it directly to the task. LoopForge provides context — the Agent
+ *  provides the reasoning strategy. */
+function buildL2Prompt(request, goalId, constraints, loopObjective, rollingText) {
+    const ctx = {
+        request, goalId, constraints, loopObjective, rollingText, level: "l2",
+    };
+    const lines = [
+        `## LoopForge L2 Compile — Round ${request.round}`,
+        "",
+    ];
+    // Cross-round summary
+    if (rollingText) {
+        lines.push(rollingText);
+        lines.push("");
+    }
+    // Technique Selection — Agent freely chooses
+    lines.push("### Technique Selection", "", "This is a strategy restart point. Read the technique catalog to choose", "the best reasoning approach for this round:", "", `  \`${SKILLS_DIR}/prompt-techniques/SKILL.md\``, "", "Based on the loop state (state file + context below), freely select", "the technique that best fits this round's challenge. Then read the", "full reference for your chosen technique:", "", `  \`${SKILLS_DIR}/prompt-techniques/references/<chosen>.md\``, "", "Apply the technique's method directly to the task — do NOT generate", "an intermediate prompt. Execute the task using the chosen technique", "as your thinking framework.", "");
+    // Loop Objective
+    lines.push(...buildLoopObjectiveBlock(loopObjective));
+    // Active Constraints
+    lines.push(...buildConstraintsBlock(constraints));
+    // Plan Source
+    if (request.plan_source) {
+        lines.push(`**Plan Source**: ${request.plan_source}`);
+        lines.push("");
+    }
+    // Task
+    lines.push(...buildTaskBlock(ctx));
+    // Loop Identity
+    lines.push(...buildIdentityBlock(ctx));
+    return lines.join("\n");
+}
 function buildHeader(ctx, technique) {
+    const levelLabel = ctx.level.toUpperCase();
     const lines = [
-        `## LoopForge L2 Compile — Round ${ctx.request.round}`,
+        `## LoopForge ${levelLabel} Compile — Round ${ctx.request.round}`,
         `**Technique**: ${technique} (embedded)`,
         "",
     ];
@@ -1577,267 +2047,85 @@ function buildIdentityBlock(ctx) {
     ];
 }
 /** Generic compiler — reads technique reference file (fallback for zero-shot/few-shot/cot). */
-function compileGeneric(request, goalId, constraints, loopObjective, rollingText, analysis, referenceFile, technique) {
-    const ctx = { request, goalId, constraints, loopObjective, rollingText };
+function compileGeneric(request, goalId, constraints, loopObjective, rollingText, analysis, referenceFile, technique, opts = {}) {
+    const embedSkeleton = opts.embedSkeleton !== false; // default true
+    const ctx = { request, goalId, constraints, loopObjective, rollingText, level: opts.level ?? "l2" };
     const lines = [
         ...buildHeader(ctx, technique),
-        `Read the technique reference BEFORE generating the prompt:`,
-        `  Technique:  ${technique}`,
-        `  Reference:  ${referenceFile}`,
-        `  Rationale:  ${analysis.rationale}`,
-        "",
-        ...buildLoopObjectiveBlock(loopObjective),
-        ...buildConstraintsBlock(constraints),
-        ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []),
-        ...buildTaskBlock(ctx),
-        ...buildIdentityBlock(ctx),
-        "### Generation Instructions",
-        `1. Read \`${referenceFile}\` — study its structure rules, section count, and format requirements`,
-        "2. Generate a complete prompt following that technique's structure",
-        "3. Inject all hard constraints and the loop objective into the prompt",
-        "4. If Cross-Round Summary is present above, incorporate its recurring issues and key lessons",
-        "5. The prompt must be self-contained — ready for a coding agent to execute",
-        "6. Output only the generated prompt — no preamble, no meta-commentary",
     ];
+    if (embedSkeleton) {
+        lines.push(`Read the technique reference BEFORE generating the prompt:`, `  Technique:  ${technique}`, `  Reference:  ${referenceFile}`, `  Rationale:  ${analysis.rationale}`, "");
+    }
+    else {
+        lines.push(`**Technique**: ${technique} (see state file for full reference)`, `**Rationale**: ${analysis.rationale}`, "");
+    }
+    lines.push(...buildLoopObjectiveBlock(loopObjective), ...buildConstraintsBlock(constraints), ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []), ...buildTaskBlock(ctx), ...buildIdentityBlock(ctx));
+    if (embedSkeleton) {
+        lines.push("### Generation Instructions", `1. Read \`${referenceFile}\` — study its structure rules, section count, and format requirements`, "2. Generate a complete prompt following that technique's structure", "3. The prompt must be self-contained — ready for a coding agent to execute", "4. Output only the generated prompt — no preamble, no meta-commentary");
+    }
     return lines.join("\n");
 }
 // ── Step-Back specialist ───────────────────────────────────────────────────────
-function compileStepBack(request, goalId, constraints, loopObjective, rollingText, analysis) {
-    const ctx = { request, goalId, constraints, loopObjective, rollingText };
+function compileStepBack(request, goalId, constraints, loopObjective, rollingText, analysis, opts = {}) {
+    const embedSkeleton = opts.embedSkeleton !== false; // default true
+    const ctx = { request, goalId, constraints, loopObjective, rollingText, level: opts.level ?? "l2" };
     const lines = [
         ...buildHeader(ctx, "step-back"),
         `**Rationale**: ${analysis.rationale}`,
         "",
-        "Generate a complete prompt using the **Step-Back** technique. Follow the 8-section skeleton below.",
-        "Embed all structural constraints — do NOT reference an external file.",
-        "",
-        ...buildLoopObjectiveBlock(loopObjective),
-        ...buildConstraintsBlock(constraints),
-        ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []),
-        ...buildTaskBlock(ctx),
-        ...buildIdentityBlock(ctx),
-        "",
-        "### 8-Section Skeleton (REQUIRED)",
-        "",
-        "| # | Section | Required | Notes |",
-        "|---|---------|----------|-------|",
-        "| 1 | 角色 | ✓ | Domain expert role appropriate to the task |",
-        "| 2 | 任务 | ✓ | One-sentence task summary |",
-        "| 3 | 输入 | ✓ | Target module/problem to analyse |",
-        "| 4 | 输出格式 | ✓ | Numbered list of expected outputs |",
-        "| 5 | **Step-Back 抽象框架** | ✓ | See format rules below |",
-        "| 6 | 具体实现要求 | ✓ | MUST start with: **\"基于上述抽象框架，实现以下所有功能\"** |",
-        "| 7 | 硬约束 | ✓ | Numbered list of hard constraints |",
-        "| 8 | 生成要求 | ✓ | Acceptance criteria |",
-        "",
-        "### Section 5 — Step-Back 抽象框架 (CRITICAL)",
-        "",
-        "Must contain **2-3 abstract frameworks**. Each framework is an independent ASCII diagram.",
-        "Frameworks are PARALLEL (peer-level), not sequential.",
-        "",
-        "Each framework format:",
-        "```",
-        "### 框架N：[Framework Name]",
-        "",
-        "[ASCII diagram with principles/formulas/classification tables/rule tables]",
-        "",
-        "Diagram content requirements:",
-        "- Core principle/formula (e.g. \"Total = Σ(dimension × weight)\")",
-        "- Component table (e.g. weight allocation table, type mapping table)",
-        "- Rule description (e.g. \"Missing data dimensions use neutral value\")",
-        "```",
-        "",
-        "**Tightening rules**:",
-        "- The step-back question must be MORE ABSTRACT than the original problem, but cover all required information",
-        "- Abstract ≠ vague. Use precise formulas, principles, standards, definitions, or causal mechanisms",
-        "- Tighten to the MINIMUM generalisation layer that still covers the original problem",
-        "- Reasoning must RETURN to the original problem — do not stay at the principle level",
-        "",
-        "**Section 6 transition sentence (MANDATORY)**:",
-        "\"基于上述抽象框架，实现以下所有功能。\"",
-        "",
-        "### Quality Checklist",
-        "- [ ] Frameworks are abstract concepts/formulas/principles, NOT concrete code",
-        "- [ ] Section 6 starts with the mandatory transition sentence",
-        "- [ ] Abstraction level is consistent across frameworks",
-        "- [ ] Step-back question is tightened to minimum necessary generalisation",
-        "",
-        "### Generation Instructions",
-        "1. Extract 2-3 abstract principles/frameworks from the task domain",
-        "2. Build ASCII diagrams for each framework (formulas, tables, rules)",
-        "3. Apply the abstraction back to the concrete task",
-        "4. Inject all hard constraints and the loop objective into the prompt",
-        "5. If Cross-Round Summary is present above, incorporate its recurring issues and key lessons",
-        "6. Output only the generated prompt — no preamble, no meta-commentary",
     ];
+    if (embedSkeleton) {
+        lines.push("Generate a complete prompt using the **Step-Back** technique. Follow the 8-section skeleton below.", "Embed all structural constraints — do NOT reference an external file.", "");
+    }
+    else {
+        lines.push("**Technique**: step-back (see state file for the full skeleton).", "Generate a complete prompt following this technique.", "");
+    }
+    lines.push(...buildLoopObjectiveBlock(loopObjective), ...buildConstraintsBlock(constraints), ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []), ...buildTaskBlock(ctx), ...buildIdentityBlock(ctx));
+    if (embedSkeleton) {
+        lines.push("", "### 8-Section Skeleton (REQUIRED)", "", "| # | Section | Required | Notes |", "|---|---------|----------|-------|", "| 1 | 角色 | ✓ | Domain expert role appropriate to the task |", "| 2 | 任务 | ✓ | One-sentence task summary |", "| 3 | 输入 | ✓ | Target module/problem to analyse |", "| 4 | 输出格式 | ✓ | Numbered list of expected outputs |", "| 5 | **Step-Back 抽象框架** | ✓ | See format rules below |", "| 6 | 具体实现要求 | ✓ | MUST start with: **\"基于上述抽象框架，实现以下所有功能\"** |", "| 7 | 硬约束 | ✓ | Numbered list of hard constraints |", "| 8 | 生成要求 | ✓ | Acceptance criteria |", "", "### Section 5 — Step-Back 抽象框架 (CRITICAL)", "", "Must contain **2-3 abstract frameworks**. Each framework is an independent ASCII diagram.", "Frameworks are PARALLEL (peer-level), not sequential.", "", "Each framework format:", "```", "### 框架N：[Framework Name]", "", "[ASCII diagram with principles/formulas/classification tables/rule tables]", "", "Diagram content requirements:", "- Core principle/formula (e.g. \"Total = Σ(dimension × weight)\")", "- Component table (e.g. weight allocation table, type mapping table)", "- Rule description (e.g. \"Missing data dimensions use neutral value\")", "```", "", "**Tightening rules**:", "- The step-back question must be MORE ABSTRACT than the original problem, but cover all required information", "- Abstract ≠ vague. Use precise formulas, principles, standards, definitions, or causal mechanisms", "- Tighten to the MINIMUM generalisation layer that still covers the original problem", "- Reasoning must RETURN to the original problem — do not stay at the principle level", "", "**Section 6 transition sentence (MANDATORY)**:", "\"基于上述抽象框架，实现以下所有功能。\"", "", "### Generation Instructions", "1. Extract 2-3 abstract principles/frameworks from the task domain", "2. Build ASCII diagrams for each framework (formulas, tables, rules)", "3. Apply the abstraction back to the concrete task", "4. Verify: the generated prompt satisfies all structural rules in the skeleton above", "5. Output only the generated prompt — no preamble, no meta-commentary");
+    }
     return lines.join("\n");
 }
 // ── Least-to-Most specialist ───────────────────────────────────────────────────
-function compileLeastToMost(request, goalId, constraints, loopObjective, rollingText, analysis) {
-    const ctx = { request, goalId, constraints, loopObjective, rollingText };
+function compileLeastToMost(request, goalId, constraints, loopObjective, rollingText, analysis, opts = {}) {
+    const embedSkeleton = opts.embedSkeleton !== false; // default true
+    const ctx = { request, goalId, constraints, loopObjective, rollingText, level: opts.level ?? "l2" };
     const lines = [
         ...buildHeader(ctx, "least-to-most"),
         `**Rationale**: ${analysis.rationale}`,
         "",
-        "Generate a complete prompt using the **Least-to-Most** technique. Follow the 8-section skeleton below.",
-        "Embed all structural constraints — do NOT reference an external file.",
-        "",
-        ...buildLoopObjectiveBlock(loopObjective),
-        ...buildConstraintsBlock(constraints),
-        ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []),
-        ...buildTaskBlock(ctx),
-        ...buildIdentityBlock(ctx),
-        "",
-        "### 8-Section Skeleton (REQUIRED)",
-        "",
-        "| # | Section | Required | Notes |",
-        "|---|---------|----------|-------|",
-        "| 1 | 角色 | ✓ | Domain expert role appropriate to the task |",
-        "| 2 | 任务 | ✓ | One-sentence task summary |",
-        "| 3 | 输入 | ✓ | Target module |",
-        "| 4 | 输出格式 | ✓ | Numbered list (e.g. \"1. DDL, 2. API, 3. Enum...\") |",
-        "| 5 | **Least-to-Most 逐步推理框架** | ✓ | See format rules below |",
-        "| 6 | 具体实现要求 | ✓ | Expand per output format list (NOT per sub-problem — sub-problems fully expanded in §5) |",
-        "| 7 | 硬约束 | ✓ | Numbered list |",
-        "| 8 | 生成要求 | ✓ | Acceptance criteria, must include: \"严格按照子问题顺序逐步实现\" |",
-        "",
-        "### Section 5 — Least-to-Most 逐步推理框架 (CRITICAL)",
-        "",
-        "Must contain **4-6 ordered sub-problems**. Each sub-problem format:",
-        "",
-        "```",
-        "### 子问题 N：[Sub-problem Name]",
-        "",
-        "**目标：** [What this sub-problem solves, which prior sub-problem(s) it depends on]",
-        "",
-        "**要求：**",
-        "- Specific requirement list",
-        "- [If sub-problem involves enums/mapping tables, list them]",
-        "",
-        "---",
-        "```",
-        "",
-        "**Critical rules**:",
-        "- Sub-problem 1 is the SIMPLEST (e.g. \"Define enums and base data structures\")",
-        "- Each sub-problem declares: \"基于子问题 N-1 的结论\"",
-        "- The LAST sub-problem MUST be: **\"综合实现完整模块\"** — list all components to integrate",
-        "- Sub-problems separated by `---`",
-        "- Order goes from LEAST complex → MOST complex, dependency chain must be explicit",
-        "- Each sub-problem must serve the original task — no unrelated steps",
-        "- The final sub-problem must be equivalent to or directly address the original task",
-        "",
-        "### Quality Checklist",
-        "- [ ] Sub-problems ordered simplest → most complex, dependency chain explicit",
-        "- [ ] Each sub-problem declares its prerequisite sub-problems",
-        "- [ ] Last sub-problem is \"综合实现完整模块\" with integration list",
-        "- [ ] Section 6 expands per output format list (NOT per sub-problem)",
-        "- [ ] Sub-problem count: 4-6, no more, no less",
-        "",
-        "### Generation Instructions",
-        "1. Decompose the task into 4-6 ordered sub-problems with explicit dependencies",
-        "2. Sub-problem 1 starts with the simplest building block (data structures, enums, base config)",
-        "3. Each subsequent sub-problem builds on prior results",
-        "4. Final sub-problem integrates all components into the complete module",
-        "5. Inject all hard constraints and the loop objective into the prompt",
-        "6. If Cross-Round Summary is present above, incorporate its recurring issues and key lessons",
-        "7. Output only the generated prompt — no preamble, no meta-commentary",
     ];
+    if (embedSkeleton) {
+        lines.push("Generate a complete prompt using the **Least-to-Most** technique. Follow the 8-section skeleton below.", "Embed all structural constraints — do NOT reference an external file.", "");
+    }
+    else {
+        lines.push("**Technique**: least-to-most (see state file for the full skeleton).", "Generate a complete prompt following this technique.", "");
+    }
+    lines.push(...buildLoopObjectiveBlock(loopObjective), ...buildConstraintsBlock(constraints), ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []), ...buildTaskBlock(ctx), ...buildIdentityBlock(ctx));
+    if (embedSkeleton) {
+        lines.push("", "### 8-Section Skeleton (REQUIRED)", "", "| # | Section | Required | Notes |", "|---|---------|----------|-------|", "| 1 | 角色 | ✓ | Domain expert role appropriate to the task |", "| 2 | 任务 | ✓ | One-sentence task summary |", "| 3 | 输入 | ✓ | Target module |", "| 4 | 输出格式 | ✓ | Numbered list (e.g. \"1. DDL, 2. API, 3. Enum...\") |", "| 5 | **Least-to-Most 逐步推理框架** | ✓ | See format rules below |", "| 6 | 具体实现要求 | ✓ | Expand per output format list (NOT per sub-problem — sub-problems fully expanded in §5) |", "| 7 | 硬约束 | ✓ | Numbered list |", "| 8 | 生成要求 | ✓ | Acceptance criteria, must include: \"严格按照子问题顺序逐步实现\" |", "", "### Section 5 — Least-to-Most 逐步推理框架 (CRITICAL)", "", "Must contain **4-6 ordered sub-problems**. Each sub-problem format:", "", "```", "### 子问题 N：[Sub-problem Name]", "", "**目标：** [What this sub-problem solves, which prior sub-problem(s) it depends on]", "", "**要求：**", "- Specific requirement list", "- [If sub-problem involves enums/mapping tables, list them]", "", "---", "```", "", "**Critical rules**:", "- Sub-problem 1 is the SIMPLEST (e.g. \"Define enums and base data structures\")", "- Each sub-problem declares: \"基于子问题 N-1 的结论\"", "- The LAST sub-problem MUST be: **\"综合实现完整模块\"** — list all components to integrate", "- Sub-problems separated by `---`", "- Order goes from LEAST complex → MOST complex, dependency chain must be explicit", "- Each sub-problem must serve the original task — no unrelated steps", "- The final sub-problem must be equivalent to or directly address the original task", "", "### Generation Instructions", "1. Decompose the task into 4-6 ordered sub-problems with explicit dependencies", "2. Sub-problem 1 starts with the simplest building block (data structures, enums, base config)", "3. Each subsequent sub-problem builds on prior results", "4. Final sub-problem integrates all components into the complete module", "5. Verify: the generated prompt satisfies all structural rules in the skeleton above", "6. Output only the generated prompt — no preamble, no meta-commentary");
+    }
     return lines.join("\n");
 }
 // ── Tree-of-Thought specialist ──────────────────────────────────────────────────
-function compileToT(request, goalId, constraints, loopObjective, rollingText, analysis) {
-    const ctx = { request, goalId, constraints, loopObjective, rollingText };
+function compileToT(request, goalId, constraints, loopObjective, rollingText, analysis, opts = {}) {
+    const embedSkeleton = opts.embedSkeleton !== false; // default true
+    const ctx = { request, goalId, constraints, loopObjective, rollingText, level: opts.level ?? "l2" };
     const lines = [
         ...buildHeader(ctx, "tree-of-thought"),
         `**Rationale**: ${analysis.rationale}`,
         "",
-        "Generate a complete prompt using the **Tree-of-Thought** technique. Follow the 8-section skeleton below.",
-        "Embed all structural constraints — do NOT reference an external file.",
-        "",
-        ...buildLoopObjectiveBlock(loopObjective),
-        ...buildConstraintsBlock(constraints),
-        ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []),
-        ...buildTaskBlock(ctx),
-        ...buildIdentityBlock(ctx),
-        "",
-        "### 8-Section Skeleton (REQUIRED)",
-        "",
-        "| # | Section | Required | Notes |",
-        "|---|---------|----------|-------|",
-        "| 1 | 角色 | ✓ | Multi-path problem-solving expert; may introduce 3 expert personas |",
-        "| 2 | 任务 | ✓ | One-sentence task summary |",
-        "| 3 | 输入 | ✓ | High-risk complex problem |",
-        "| 4 | 输出格式 | ✓ | \"先输出思维树过程，再输出最终答案/方案\" |",
-        "| 5 | **思维树探索框架** | ✓ | See 3 sub-blocks below (REQUIRED) |",
-        "| 6 | 具体实现要求 | ✓ | Expand per output format |",
-        "| 7 | 硬约束 | ✓ | Include branch_count, max_depth, pruning rules, safety/performance constraints |",
-        "| 8 | 生成要求 | ✓ | \"先探索多路径，再选择最优方案\" |",
-        "",
-        "### Section 5 — 思维树探索框架 (CRITICAL — 3 sub-blocks REQUIRED)",
-        "",
-        "**Sub-block A: Search Strategy Declaration**",
-        "```",
-        "搜索策略: [beam / dfs / expert-panel]",
-        "分支数(branch_count): 2-4",
-        "最大深度(max_depth): ≤3",
-        "每轮保留数(keep_count): 1-2",
-        "```",
-        "Strategy selection guide:",
-        "- **beam** (default): planning, creative, math search — generate multiple candidates per turn, keep top b",
-        "- **dfs**: puzzles, constraint satisfaction, debugging — go deep on highest-score branch, backtrack on failure",
-        "- **expert-panel**: 3+ experts each generate candidates, then cross-evaluate and revise",
-        "",
-        "**Sub-block B: Evaluation Criteria Table**",
-        "| 标准 | 权重 | 说明 |",
-        "|------|------|------|",
-        "| 正确性 | 最高 | Logic/math correctness |",
-        "| 可行性 | 高 | Can be actually implemented |",
-        "| 约束匹配 | 高 | Satisfies hard constraints |",
-        "| 性能 | 中 | Time/space efficiency |",
-        "| 安全性 | 最高 | No vulnerabilities/privilege escalation |",
-        "",
-        "**Sub-block C: Thought Tree State Table Format**",
-        "Require the model to output in this table format:",
-        "```",
-        "| 轮次 | 分支 | 候选方案 | 评估 | 决策 |",
-        "|------|------|---------|------|------|",
-        "| 1    | A    | [方案描述] | 评分/判断 | 保留/剪枝 |",
-        "| 1    | B    | [方案描述] | 评分/判断 | 保留/剪枝 |",
-        "| 1    | C    | [方案描述] | 评分/判断 | 保留/剪枝 |",
-        "| 2    | A1   | [深入展开] | ... | ... |",
-        "| ...  | ...  | ...       | ... | ... |",
-        "",
-        "最终选择: [最优方案 + 选择理由]",
-        "```",
-        "",
-        "### Critical Rules",
-        "- Hard constraints MUST be ranked FIRST in evaluation criteria",
-        "- Branch count: 2-4, depth: ≤3 (prevents token explosion)",
-        "- Every turn: generate multiple candidates → evaluate → keep/prune — never single-path",
-        "- If all branches are low quality: backtrack to previous turn and regenerate",
-        "- The core of ToT is NOT \"3 experts chatting\" — it's: candidate generation → state evaluation → search/prune → final selection",
-        "- thought is a PUBLIC intermediate semantic unit, not hidden chain-of-thought",
-        "- State table MUST have: round, branch ID, candidate description, evaluation score/judgment, keep/prune decision",
-        "",
-        "### Quality Checklist",
-        "- [ ] Branch count 2-4, depth ≤3 (prevents token explosion)",
-        "- [ ] Evaluation criteria table has ≥3 dimensions including correctness, feasibility, constraint matching",
-        "- [ ] State table format explicit (round/branch/candidate/evaluation/decision)",
-        "- [ ] Search strategy matches task type (beam/dfs/expert-panel)",
-        "- [ ] Hard constraints listed FIRST in evaluation criteria",
-        "- [ ] Not \"3 experts casually discussing\" — has explicit branch count, depth, scoring, and pruning rules",
-        "- [ ] Ends with model outputting final selection and rationale",
-        "",
-        "### Generation Instructions",
-        "1. Select the appropriate search strategy (beam/dfs/expert-panel) based on task type",
-        "2. Define 2-4 candidate approaches as initial branches",
-        "3. Build evaluation criteria table with hard constraints ranked first",
-        "4. Define the state table format for tracking exploration",
-        "5. Set branch count and max depth to prevent token explosion",
-        "6. Inject all hard constraints and the loop objective into the prompt",
-        "7. If Cross-Round Summary is present above, incorporate its recurring issues and key lessons",
-        "8. Output only the generated prompt — no preamble, no meta-commentary",
     ];
+    if (embedSkeleton) {
+        lines.push("Generate a complete prompt using the **Tree-of-Thought** technique. Follow the 8-section skeleton below.", "Embed all structural constraints — do NOT reference an external file.", "");
+    }
+    else {
+        lines.push("**Technique**: tree-of-thought (see state file for the full skeleton).", "Generate a complete prompt following this technique.", "");
+    }
+    lines.push(...buildLoopObjectiveBlock(loopObjective), ...buildConstraintsBlock(constraints), ...(request.plan_source ? [`**Plan Source**: ${request.plan_source}`, ""] : []), ...buildTaskBlock(ctx), ...buildIdentityBlock(ctx));
+    if (embedSkeleton) {
+        lines.push("", "### 8-Section Skeleton (REQUIRED)", "", "| # | Section | Required | Notes |", "|---|---------|----------|-------|", "| 1 | 角色 | ✓ | Multi-path problem-solving expert; may introduce 3 expert personas |", "| 2 | 任务 | ✓ | One-sentence task summary |", "| 3 | 输入 | ✓ | High-risk complex problem |", "| 4 | 输出格式 | ✓ | \"先输出思维树过程，再输出最终答案/方案\" |", "| 5 | **思维树探索框架** | ✓ | See 3 sub-blocks below (REQUIRED) |", "| 6 | 具体实现要求 | ✓ | Expand per output format |", "| 7 | 硬约束 | ✓ | Include branch_count, max_depth, pruning rules, safety/performance constraints |", "| 8 | 生成要求 | ✓ | \"先探索多路径，再选择最优方案\" |", "", "### Section 5 — 思维树探索框架 (CRITICAL — 3 sub-blocks REQUIRED)", "", "**Sub-block A: Search Strategy Declaration**", "```", "搜索策略: [beam / dfs / expert-panel]", "分支数(branch_count): 2-4", "最大深度(max_depth): ≤3", "每轮保留数(keep_count): 1-2", "```", "Strategy selection guide:", "- **beam** (default): planning, creative, math search — generate multiple candidates per turn, keep top b", "- **dfs**: puzzles, constraint satisfaction, debugging — go deep on highest-score branch, backtrack on failure", "- **expert-panel**: 3+ experts each generate candidates, then cross-evaluate and revise", "", "**Sub-block B: Evaluation Criteria Table**", "| 标准 | 权重 | 说明 |", "|------|------|------|", "| 正确性 | 最高 | Logic/math correctness |", "| 可行性 | 高 | Can be actually implemented |", "| 约束匹配 | 高 | Satisfies hard constraints |", "| 性能 | 中 | Time/space efficiency |", "| 安全性 | 最高 | No vulnerabilities/privilege escalation |", "", "**Sub-block C: Thought Tree State Table Format**", "Require the model to output in this table format:", "```", "| 轮次 | 分支 | 候选方案 | 评估 | 决策 |", "|------|------|---------|------|------|", "| 1    | A    | [方案描述] | 评分/判断 | 保留/剪枝 |", "| 1    | B    | [方案描述] | 评分/判断 | 保留/剪枝 |", "| 1    | C    | [方案描述] | 评分/判断 | 保留/剪枝 |", "| 2    | A1   | [深入展开] | ... | ... |", "| ...  | ...  | ...       | ... | ... |", "", "最终选择: [最优方案 + 选择理由]", "```", "", "### Critical Rules", "- Hard constraints MUST be ranked FIRST in evaluation criteria", "- Branch count: 2-4, depth: ≤3 (prevents token explosion)", "- Every turn: generate multiple candidates → evaluate → keep/prune — never single-path", "- If all branches are low quality: backtrack to previous turn and regenerate", "- The core of ToT is NOT \"3 experts chatting\" — it's: candidate generation → state evaluation → search/prune → final selection", "- thought is a PUBLIC intermediate semantic unit, not hidden chain-of-thought", "- State table MUST have: round, branch ID, candidate description, evaluation score/judgment, keep/prune decision", "", "### Generation Instructions", "1. Select the appropriate search strategy (beam/dfs/expert-panel) based on task type", "2. Define 2-4 candidate approaches as initial branches", "3. Build evaluation criteria table with hard constraints ranked first", "4. Define the state table format for tracking exploration", "5. Set branch count and max depth to prevent token explosion", "6. Verify: the generated prompt satisfies all structural rules in the skeleton above", "7. Output only the generated prompt — no preamble, no meta-commentary");
+    }
     return lines.join("\n");
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1874,7 +2162,9 @@ export function buildSelfEvalBlock(round) {
         '  },',
         '  "retracted_constraints": [],',
         '  "revised_success_criteria": [],',
-        '  "wrong_assumptions": []',
+        '  "wrong_assumptions": [],',
+        '  "compression_checkpoint": false,',
+        '  "checkpoint_label": ""',
         "}",
         "---end-loopforge-eval",
         "```",
@@ -1907,6 +2197,15 @@ export function buildSelfEvalBlock(round) {
             `Array of {old, new} objects. Applied to the Loop Objective. Omit or [] if none.`,
         `- wrong_assumptions (P5 — optional): Assumptions from earlier rounds that turned ` +
             `out to be incorrect. Recorded as key lessons. Omit or [] if none.`,
+        `- compression_checkpoint (v1.10 — optional): Set to true when you have COMPLETED a ` +
+            `major subtask. The compiler will snapshot the current state (constraints, outcome) ` +
+            `into a persistent checkpoint that survives context-window eviction. ` +
+            `Use sparingly — only at genuine subtask boundaries, not every round. ` +
+            `Omit or false otherwise.`,
+        `- checkpoint_label (v1.10 — optional): Human-readable label for this checkpoint. ` +
+            `e.g. "数据模型层完成", "API layer complete", "Auth module done". ` +
+            `Used as the checkpoint heading in subsequent prompts. Only meaningful when ` +
+            `compression_checkpoint is true. Omit or "" otherwise.`,
         `- The JSON MUST appear between the ---loopforge-eval and ---end-loopforge-eval markers`,
         `- Do NOT wrap the markers in code fences — output them as raw text`,
         "",