loopforge 3.0.0 → 3.2.1

package/dist/prompt-assembler.js

@@ -5,12 +5,11 @@
  * are never truncated; budgets are soft and overflow is recorded.
  */
 import { createHash } from "node:crypto";
-import { deriveItemId } from "./derive-id.js";
 import { hashCanonicalState } from "./canonical-state.js";
-import { jaccardSimilarity } from "./token-utils.js";
+import { deriveItemId, STABLE_ID_RE, jaccardSimilarity } from "./token-utils.js";
 import { getPolicy } from "./policy.js";
-export const PROMPT_ARTIFACT_FORMAT = "loopforge.prompt";
-export const BASE_PROMPT_VERSION = "stable";
+export const PROMPT_ARTIFACT_SCHEMA_VERSION = 1;
+export const BASE_PROMPT_VERSION = "2.0.0";
 export const DEFAULT_PROMPT_BUDGETS = {
     l0: 3000,
     l1: 7000,
@@ -31,22 +30,62 @@ function bulletsWithIds(values, prefix) {
     const idEnabled = getPolicy().evolution.constraint_id_enabled;
     if (!idEnabled)
         return bullets(values);
-    const idRegex = /^(c|cr|sg)-[a-f0-9]{8}$/;
     return values.map((v) => {
         const trimmed = v.trim();
-        if (idRegex.test(trimmed)) {
+        if (STABLE_ID_RE.test(trimmed)) {
             return `- [\`${trimmed}\`] ${trimmed}`;
         }
         const id = prefix + "-" + deriveItemId(trimmed);
         return `- [\`${id}\`] ${trimmed}`;
     }).join("\n");
 }
-function verificationText(state) {
+/** v3.2: Short imperative fix/action per verification check, appended to the
+ *  L1/L2 Verification Gate lines. Deliberately shorter than the rejection-
+ *  prompt wording in enforcement-gate.ts; keys are the plain check-name
+ *  strings (NOT imported from verification-gate.ts — it already imports
+ *  loop-compiler, which imports this module, so importing back would cycle).
+ *  Full coverage of the 19 CHECK_* constants is enforced by a test. */
+const VERIFICATION_ACTIONS = {
+    progress_regression: "Correct progress_estimate or explain the change in output_summary.",
+    empty_change_with_passing: "Report the actual files_changed, or set success=false with the real state.",
+    success_with_remaining_criteria: "Complete the remaining criteria before claiming success, or set success=false and report what remains.",
+    success_without_verified_evidence: "Back the success claim with machine-verifiable evidence: run tests or a required verification command and report the actual output.",
+    outcome_success_contradiction: "Reconcile the declared outcome with the success flag and resubmit an honest evaluation.",
+    success_claim_conflict: "Align the success claim with your own evaluation data before resubmitting.",
+    blocked_without_blocker: "State the concrete blocker, or drop the blocked outcome.",
+    retroactive_claim_bad_round: "Correct the referenced round number, or withdraw the retroactive claim.",
+    retroactive_claim_unverified: "Provide evidence for the retroactive claim, or withdraw it.",
+    duplicate_constraint_discovery: "Update the existing constraint entry instead of duplicating it.",
+    recurring_violation: "Explain why this violation keeps recurring and try a different approach — do not repeat the failed strategy.",
+    retract_fresh_constraint: "Justify the retraction explicitly, or restore the constraint.",
+    evidence_integrity: "Correct the mismatch between your claims and the recorded evidence.",
+    required_command_failed: "Re-run the required verification command and report its actual output before claiming success.",
+    command_evidence_mismatch: "Report the true command output and reconcile the mismatch.",
+    intent_drift: "Explain the pivot in drift_clarification with concrete references, or redo the round as promised.",
+    subgoal_drift: "Reconcile the sub-goal list with your reported work before resubmitting.",
+    backtrack_workspace_not_restored: "Restore the skipped-round files and the expected git HEAD, then resubmit.",
+    criteria_claims_unverified: "Provide evidence for each claimed success criterion.",
+};
+/** Fallback for unmapped check names (forward-compat with future checks). */
+const VERIFICATION_ACTION_FALLBACK = "Re-examine the flagged claim and correct your evaluation before resubmitting.";
+/** v3.2: The actionable instruction for a verification check. Exported for
+ *  the coverage test (which imports the CHECK_* constants). */
+export function verificationActionFor(check) {
+    return VERIFICATION_ACTIONS[check] ?? VERIFICATION_ACTION_FALLBACK;
+}
+function verificationText(state, level) {
     const lines = state.verificationFlags.map((flag) => {
         const icon = flag.severity === "error"
             ? "🚫"
             : flag.severity === "warn" ? "⚠️" : "ℹ️";
-        return `- ${icon} [${flag.check}] ${flag.detail}`;
+        const base = `- ${icon} [${flag.check}] ${flag.detail}`;
+        // v3.2: error/warn flags get an actionable continuation line in L1/L2 —
+        // the verdict is translated into what to DO. L0 keeps the compact retry
+        // prompt byte-identical; info flags stay informational.
+        if (level === "l0" || flag.severity === "info")
+            return base;
+        const label = flag.severity === "error" ? "Fix" : "Action";
+        return `${base}\n  → ${label}: ${verificationActionFor(flag.check)}`;
     });
     if (state.verificationFlags.some((flag) => flag.severity === "error")) {
         lines.push("- Gate Verdict: CONTRADICTED — resolve every error before claiming success.");
@@ -57,6 +96,81 @@ function activeNonHardConstraints(state) {
     const hard = new Set(state.hardConstraints);
     return state.activeConstraints.filter((value) => !hard.has(value));
 }
+// ═══════════════════════════════════════════════════════════════════════════
+// v3.2: L1 diff-collapse helpers
+// ═══════════════════════════════════════════════════════════════════════════
+/** v3.2: Collapse only when at least this many items are unchanged — a tiny
+ *  unchanged set renders in full (nothing worth saving). */
+export const COLLAPSE_MIN_UNCHANGED = 3;
+/** v3.2: Recent-rounds items kept in full when older ones collapse. */
+export const KEEP_RECENT_ROUNDS = 3;
+/** v3.2: Stable ID of a constraint text as rendered by bulletsWithIds —
+ *  metadata's own id when present, else the derived hash. */
+function constraintIdOf(text, metadata) {
+    const meta = metadata.find((m) => m.text === text);
+    return meta?.id ?? `c-${deriveItemId(text)}`;
+}
+export function diffConstraints(baseline, activeTexts, metadata, round, emphasized) {
+    if (!baseline)
+        return { changed: activeTexts, unchangedCount: 0, removedCount: 0 };
+    const baselineIds = new Set(baseline.constraintIds);
+    const currentIds = new Set(activeTexts.map((text) => constraintIdOf(text, metadata)));
+    const changed = [];
+    let unchangedCount = 0;
+    for (const text of activeTexts) {
+        const id = constraintIdOf(text, metadata);
+        const violatedThisRound = metadata.find((m) => m.text === text)
+            ?.last_violated_at_round === round;
+        if (!baselineIds.has(id) || violatedThisRound)
+            changed.push(text);
+        else
+            unchangedCount++;
+    }
+    let removedCount = 0;
+    if (emphasized.size > 0) {
+        const emphasizedIds = new Set([...emphasized].map((text) => constraintIdOf(text, metadata)));
+        for (const id of baselineIds) {
+            if (!currentIds.has(id) && !emphasizedIds.has(id))
+                removedCount++;
+        }
+    }
+    else {
+        for (const id of baselineIds) {
+            if (!currentIds.has(id))
+                removedCount++;
+        }
+    }
+    return { changed, unchangedCount, removedCount };
+}
+export function diffSubGoals(baseline, activeSubs) {
+    if (!baseline)
+        return { changed: activeSubs, unchangedCount: 0, removedCount: 0 };
+    const baselineById = new Map(baseline.subGoals);
+    const currentIds = new Set(activeSubs.map((sg) => sg.id));
+    const changed = [];
+    let unchangedCount = 0;
+    for (const sg of activeSubs) {
+        const prevStatus = baselineById.get(sg.id);
+        if (prevStatus === undefined || prevStatus !== sg.status)
+            changed.push(sg);
+        else
+            unchangedCount++;
+    }
+    let removedCount = 0;
+    for (const [id] of baseline.subGoals) {
+        if (!currentIds.has(id))
+            removedCount++;
+    }
+    return { changed, unchangedCount, removedCount };
+}
+/** v3.2: True when a milestone boundary was crossed since the baseline —
+ *  the Recent Rounds section then renders in full (a phase ended). */
+export function milestoneBoundaryChanged(baseline, milestones) {
+    if (!baseline)
+        return false;
+    const baselineRanges = new Set(baseline.milestoneRanges.map(([s, e]) => `${s}:${e}`));
+    return milestones.some((m) => !baselineRanges.has(`${m.round_range.start}:${m.round_range.end}`));
+}
 function commonMandatorySections(state, 
 /** v2.11: L0 skips ID rendering to stay within tight budget. */
 level) {
@@ -66,41 +180,12 @@ level) {
             text: section("Objective", state.objective),
             mandatory: true,
         },
-    ];
-    const phase = state.phaseHistory.at(-1);
-    if (phase) {
-        sections.push({
-            id: "current_phase",
-            text: section("Current Phase", `${phase.label} (${phase.status})\n${phase.outcome}`),
-            mandatory: false,
-        });
-    }
-    const focus = state.currentFocus || state.objective;
-    if (focus.trim()) {
-        sections.push({
-            id: "current_focus",
-            text: section("Current Focus", focus),
+        {
+            id: "current_task",
+            text: section("Current Task", state.currentTask),
             mandatory: true,
-        });
-    }
-    if (state.todoProjection) {
-        sections.push({
-            id: "todo_projection",
-            text: section("Active Todo Projection", `${state.todoProjection.action}\nCompletion: ${state.todoProjection.completionSignal}`),
-            mandatory: false,
-        });
-    }
-    sections.push({
-        id: "verification",
-        text: section("Verification Gate", verificationText(state) || "No verification contradiction is currently open."),
-        mandatory: true,
-    });
-    if (state.activeGate) {
-        const body = state.activeGate.kind === "user"
-            ? [`Owner: user`, `Question: ${state.activeGate.question}`, `Blocked scope: ${state.activeGate.blockedScope.join("; ")}`, `Safe work: ${state.activeGate.allowedWork.join("; ")}`].join("\n")
-            : [`Owner: agent`, `Problem: ${state.activeGate.problem}`, `Required evidence: ${state.activeGate.requiredEvidence.join("; ")}`, `Resolution: ${state.activeGate.suggestedResolution}`].join("\n");
-        sections.push({ id: "active_gate", text: section("Active Gate", body), mandatory: true });
-    }
+        },
+    ];
     if (state.hardConstraints.length > 0) {
         // v2.11: L0 uses plain bullets (tight budget); L1/L2 show constraint IDs
         const body = level === "l0"
@@ -112,6 +197,13 @@ level) {
             mandatory: true,
         });
     }
+    if (state.verificationFlags.length > 0) {
+        sections.push({
+            id: "verification",
+            text: section("Verification Gate", verificationText(state, level)),
+            mandatory: true,
+        });
+    }
     return sections;
 }
 function l0Sections(state) {
@@ -136,17 +228,10 @@ function l0Sections(state) {
     }
     return sections;
 }
-function l1Sections(state) {
+function l1Sections(state, baseline, emphasized) {
     const sections = commonMandatorySections(state, "l1");
-    const openRegression = state.regressionObligations.filter((obligation) => obligation.status !== "satisfied");
-    if (openRegression.length > 0) {
-        sections.push({
-            id: "regression_obligations",
-            text: section("Regression Obligations", bullets(openRegression.map((item) => `[${item.status}] ${item.description}`))),
-            mandatory: true,
-        });
-    }
     const active = activeNonHardConstraints(state);
+    const collapseEnabled = getPolicy().prompt.l1_collapse_enabled;
     if (state.changesSinceLastRound.length > 0) {
         sections.push({
             id: "changes",
@@ -154,12 +239,36 @@ function l1Sections(state) {
             mandatory: false,
         });
     }
+    // v3.2: Active Constraints — collapse unchanged items against the previous
+    // round's presentation; new and violated-this-round constraints render in
+    // full. The collapse line points at the state file (regenerated every
+    // round), so no information is lost — only presentation is compacted.
     if (active.length > 0) {
-        sections.push({
-            id: "active_constraints",
-            text: section("Active Constraints / Success Criteria", bulletsWithIds(active, "c")),
-            mandatory: false,
-        });
+        const diff = diffConstraints(baseline, active, state.constraintMetadata, state.round, emphasized);
+        const renderFull = !collapseEnabled || !baseline
+            || diff.unchangedCount < COLLAPSE_MIN_UNCHANGED;
+        if (renderFull) {
+            sections.push({
+                id: "active_constraints",
+                text: section("Active Constraints / Success Criteria", bulletsWithIds(active, "c")),
+                mandatory: false,
+            });
+        }
+        else {
+            const lines = diff.changed.map((text) => {
+                const id = constraintIdOf(text, state.constraintMetadata);
+                const violated = state.constraintMetadata.find((m) => m.text === text)
+                    ?.last_violated_at_round === state.round;
+                const suffix = violated ? " (violated this round)" : " (new this round)";
+                return `- [\`${id}\`] ${text}${suffix}`;
+            });
+            lines.push(`- … ${diff.unchangedCount} unchanged constraints, ${diff.removedCount} demoted since R${baseline.round} (see state file)`);
+            sections.push({
+                id: "active_constraints",
+                text: section("Active Constraints / Success Criteria", lines.join("\n")),
+                mandatory: false,
+            });
+        }
     }
     if (state.remainingCriteria.length > 0) {
         sections.push({
@@ -172,32 +281,47 @@ function l1Sections(state) {
         sections.push({
             id: "blockers",
             text: section("Blockers", bullets(state.blockers)),
-            mandatory: true,
-        });
-    }
-    if (state.handoff.verifiedFacts.length > 0) {
-        sections.push({
-            id: "verified_facts",
-            text: section("Latest Verified Facts", bulletsWithIds(state.handoff.verifiedFacts, "cr")),
-            mandatory: true,
+            mandatory: false,
         });
     }
-    // v2.2: Sub-Goal Dashboard (compact — L1)
+    // v2.2: Sub-Goal Dashboard (compact — L1). v3.2: unchanged sub-goals
+    // collapse to a count line; new/transitioned ones render in full.
     const activeSubs = state.subGoals.filter((sg) => sg.status === "in_progress" || sg.status === "pending");
     if (activeSubs.length > 0) {
-        const maxShow = 5;
-        const items = activeSubs.slice(0, maxShow).map((sg) => {
-            const icon = sg.status === "in_progress" ? "🔄" : "⏳";
-            return `${icon} [\`${sg.id}\`] ${sg.description}`;
-        });
-        if (activeSubs.length > maxShow) {
-            items.push(`... and ${activeSubs.length - maxShow} more`);
+        const diff = diffSubGoals(baseline, activeSubs);
+        const renderFull = !collapseEnabled || !baseline
+            || diff.unchangedCount < COLLAPSE_MIN_UNCHANGED;
+        if (renderFull) {
+            const maxShow = 5;
+            const items = activeSubs.slice(0, maxShow).map((sg) => {
+                const icon = sg.status === "in_progress" ? "🔄" : "⏳";
+                return `${icon} [\`${sg.id}\`] ${sg.description}`;
+            });
+            if (activeSubs.length > maxShow) {
+                items.push(`... and ${activeSubs.length - maxShow} more`);
+            }
+            sections.push({
+                id: "sub_goals",
+                text: section("Active Sub-Goals", items.join("\n")),
+                mandatory: false,
+            });
+        }
+        else {
+            const transitionCount = diff.changed.filter((sg) => {
+                const prev = baseline.subGoals.find(([id]) => id === sg.id);
+                return prev !== undefined && prev[1] !== sg.status;
+            }).length;
+            const items = diff.changed.slice(0, 5).map((sg) => {
+                const icon = sg.status === "in_progress" ? "🔄" : "⏳";
+                return `${icon} [\`${sg.id}\`] ${sg.description}`;
+            });
+            items.push(`- … ${diff.unchangedCount} unchanged sub-goals, ${transitionCount + diff.removedCount} changed since R${baseline.round} (see state file)`);
+            sections.push({
+                id: "sub_goals",
+                text: section("Active Sub-Goals", items.join("\n")),
+                mandatory: false,
+            });
         }
-        sections.push({
-            id: "sub_goals",
-            text: section("Active Sub-Goals", items.join("\n")),
-            mandatory: false,
-        });
     }
     if (state.discoveries.length > 0) {
         sections.push({
@@ -206,24 +330,63 @@ function l1Sections(state) {
             mandatory: false,
         });
     }
+    // v3.2: Recent Rounds — keep the newest KEEP_RECENT_ROUNDS in full, fold
+    // older ones into one pointer line (unless a milestone boundary crossed).
     if (state.rollingOutcomes.length > 0) {
+        const boundaryChanged = milestoneBoundaryChanged(baseline, state.milestones);
+        const collapseable = collapseEnabled && baseline !== null
+            && state.rollingOutcomes.length > KEEP_RECENT_ROUNDS && !boundaryChanged;
+        if (collapseable) {
+            const kept = state.rollingOutcomes.slice(-KEEP_RECENT_ROUNDS);
+            const earlier = state.rollingOutcomes.length - kept.length;
+            const lines = [
+                ...kept,
+                `- … ${earlier} earlier round${earlier === 1 ? "" : "s"} (see state file)`,
+            ];
+            sections.push({
+                id: "rolling_outcomes",
+                text: section("Recent Rounds", lines.join("\n")),
+                mandatory: false,
+            });
+        }
+        else {
+            sections.push({
+                id: "rolling_outcomes",
+                text: section("Recent Rounds", bullets(state.rollingOutcomes)),
+                mandatory: false,
+            });
+        }
+    }
+    // v3.2: L1 also renders the explicit external context (previously L2-only).
+    // Placed after the changes delta, within the soft budget.
+    if (state.externalContext) {
         sections.push({
-            id: "rolling_outcomes",
-            text: section("Recent Rounds", bullets(state.rollingOutcomes)),
+            id: "external_context",
+            text: section("External Context", state.externalContext),
             mandatory: false,
         });
     }
-    if (state.recurringIssues.length > 0) {
+    // v3.2: Recurring Issues carries the deterministic violation lessons (with
+    // counts and rounds) when available; falls back to the rolling window text.
+    if (state.recurringIssues.length > 0 || state.lessons.length > 0) {
+        const violationLessons = state.lessons
+            .filter((lesson) => lesson.kind === "constraint_violation")
+            .slice(0, 3);
+        const body = violationLessons.length > 0
+            ? violationLessons
+                .map((lesson) => `- ${lesson.text} (violated ${lesson.count}×: R${lesson.rounds.join(", R")})`)
+                .join("\n")
+            : bullets(state.recurringIssues);
         sections.push({
             id: "recurring_issues",
-            text: section("Recurring Issues", bullets(state.recurringIssues)),
+            text: section("Recurring Issues", body),
             mandatory: false,
         });
     }
-    if (state.suggestedNextAction) {
+    if (state.nextAction) {
         sections.push({
-            id: "agent_intent",
-            text: section("Suggested Next Action", state.suggestedNextAction),
+            id: "next_action",
+            text: section("Next Action", state.nextAction),
             mandatory: false,
         });
     }
@@ -231,14 +394,6 @@ function l1Sections(state) {
 }
 function l2Sections(state, fullStateMarkdown) {
     const sections = commonMandatorySections(state, "l2");
-    const openRegression = state.regressionObligations.filter((obligation) => obligation.status !== "satisfied");
-    if (openRegression.length > 0) {
-        sections.push({
-            id: "regression_obligations",
-            text: section("Regression Obligations", bullets(openRegression.map((item) => `[${item.status}] ${item.description}`))),
-            mandatory: true,
-        });
-    }
     const fullState = fullStateMarkdown?.trim();
     if (fullState) {
         sections.push({
@@ -255,7 +410,6 @@ function l2Sections(state, fullStateMarkdown) {
         ["changes", "Changes Since Last Round", state.changesSinceLastRound, null],
         ["remaining", "Remaining", state.remainingCriteria, "cr"],
         ["blockers", "Blockers", state.blockers, null],
-        ["verified_facts", "Latest Verified Facts", state.handoff.verifiedFacts, "cr"],
         ["discoveries", "Discoveries", state.discoveries, null],
         ["rolling_outcomes", "Cross-Round Outcomes", state.rollingOutcomes, null],
         ["recurring_issues", "Recurring Issues", state.recurringIssues, null],
@@ -266,25 +420,46 @@ function l2Sections(state, fullStateMarkdown) {
             const body = idPrefix
                 ? bulletsWithIds(values, idPrefix)
                 : bullets(values);
-            sections.push({
-                id,
-                text: section(title, body),
-                mandatory: id === "blockers" || id === "verified_facts",
-            });
+            sections.push({ id, text: section(title, body), mandatory: false });
         }
     }
-    if (state.phaseHistory.length > 0) {
-        const phaseText = state.phaseHistory
-            .map((phase) => {
-            const range = phase.closedAtRound
-                ? `R${phase.enteredAtRound}-R${phase.closedAtRound}`
-                : `R${phase.enteredAtRound}-current`;
-            return `**${phase.label}** (${range}, ${phase.status})\n  Outcome: ${phase.outcome}`;
+    // v3.2: Lessons learned — repeated violations / verification failures
+    // across the whole loop (not just the rolling window).
+    if (state.lessons.length > 0) {
+        const lessonLines = state.lessons.slice(0, 8).map((lesson) => {
+            const icon = lesson.kind === "constraint_violation"
+                ? "🚫"
+                : lesson.kind === "verification_error" ? "⚠️" : "ℹ️";
+            return `- ${icon} ${lesson.text} — ${lesson.count}× (R${lesson.rounds.join(", R")})`;
+        });
+        if (state.lessons.length > 8) {
+            lessonLines.push(`- ... and ${state.lessons.length - 8} more`);
+        }
+        sections.push({
+            id: "lessons",
+            text: section("Lessons Learned", lessonLines.join("\n")),
+            mandatory: false,
+        });
+    }
+    if (state.milestones.length > 0) {
+        const milestoneText = state.milestones
+            .map((m) => {
+            const kindIcon = m.kind === "agent_declared"
+                ? "🏁"
+                : m.kind === "criteria_milestone" ? "✅" : "📍";
+            const lines = [
+                `**${kindIcon} ${m.label}** (Rounds ${m.round_range.start}–${m.round_range.end}, ${(m.progress_at_boundary * 100).toFixed(0)}%)`,
+                `  Outcome: ${m.outcome}`,
+            ];
+            if (m.resolved_constraints.length > 0) {
+                lines.push(`  Resolved: ${m.resolved_constraints.slice(0, 3).join("; ")}`);
+            }
+            return lines.join("\n");
         })
             .join("\n\n");
         sections.push({
-            id: "phase_history",
-            text: section("Phase History", phaseText),
+            id: "milestones",
+            text: section("Phase History", milestoneText),
             mandatory: false,
         });
     }
@@ -339,10 +514,10 @@ function l2Sections(state, fullStateMarkdown) {
             mandatory: false,
         });
     }
-    if (state.suggestedNextAction) {
+    if (state.nextAction) {
         sections.push({
-            id: "agent_intent",
-            text: section("Suggested Next Action", state.suggestedNextAction),
+            id: "next_action",
+            text: section("Next Action", state.nextAction),
             mandatory: false,
         });
     }
@@ -380,6 +555,22 @@ function l2Sections(state, fullStateMarkdown) {
                 lines.push(`- ... and ${state.progress.filesChanged.length - 10} more`);
             }
         }
+        // v3.2: Goal → criteria → evidence vertical view — per-criterion status
+        // with the round it was met and linked sub-goals. IDs follow
+        // constraint_id_enabled like every other ID-rendering path.
+        if (state.criterionStatuses.length > 0) {
+            const idEnabled = getPolicy().evolution.constraint_id_enabled;
+            lines.push("", "**Goal → Criteria**:");
+            for (const cs of state.criterionStatuses) {
+                const icon = cs.status === "met" ? "✅" : cs.status === "remaining" ? "⬜" : "❔";
+                const idTag = idEnabled ? ` [\`${cs.id}\`]` : "";
+                const met = cs.met_at_round !== undefined ? `(met R${cs.met_at_round})` : "";
+                const related = cs.related_subgoal_ids.length > 0
+                    ? ` [↔ ${cs.related_subgoal_ids.join(", ")}]`
+                    : "";
+                lines.push(`- ${icon}${idTag} ${cs.text} ${met}${related}`);
+            }
+        }
         sections.push({
             id: "progress",
             text: section("Progress Dashboard", lines.join("\n")),
@@ -439,27 +630,22 @@ function l2Sections(state, fullStateMarkdown) {
     }
     return sections;
 }
-function selectSections(input) {
-    const sections = input.mode === "full"
-        ? l2Sections(input.state, input.fullStateMarkdown)
-        : input.level === "l0" ? l0Sections(input.state)
-            : input.level === "l1" ? l1Sections(input.state)
-                : l2Sections(input.state, input.fullStateMarkdown);
-    if (input.agentIntent?.trim()) {
-        sections.push({
-            id: "agent_intent",
-            text: section("Agent Intent (non-authoritative)", `${input.agentIntent.trim()}\nRuntime-derived Focus, Todo and Suggested Next Action take precedence.`),
-            mandatory: false,
-        });
+function selectSections(input, emphasized) {
+    if (input.mode === "full") {
+        return l2Sections(input.state, input.fullStateMarkdown);
     }
-    return sections;
+    if (input.level === "l0")
+        return l0Sections(input.state);
+    if (input.level === "l1") {
+        return l1Sections(input.state, input.presentedBaseline ?? null, emphasized);
+    }
+    return l2Sections(input.state, input.fullStateMarkdown);
 }
 function renderWithinBudget(sections, fixedText, budget) {
     const mandatory = sections.filter((item) => item.mandatory);
     const optional = sections.filter((item) => !item.mandatory);
     let rendered = fixedText + mandatory.map((item) => item.text).join("");
     const included = mandatory.filter((item) => item.text).map((item) => item.id);
-    const omitted = [];
     for (const item of optional) {
         if (!item.text)
             continue;
@@ -467,11 +653,8 @@ function renderWithinBudget(sections, fixedText, budget) {
             rendered += item.text;
             included.push(item.id);
         }
-        else {
-            omitted.push(item.id);
-        }
     }
-    return { rendered, included, omitted };
+    return { rendered, included };
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // v2.9: Prompt Requests — model-expressed information needs
@@ -483,13 +666,12 @@ function renderWithinBudget(sections, fixedText, budget) {
 function matchEmphasize(targets, candidates, cap) {
     if (targets.length === 0 || candidates.length === 0)
         return [];
-    const idRegex = /^(c|cr|sg)-[a-f0-9]{8}$/;
     const scored = candidates.map((c) => {
         let best = 0;
         for (const t of targets) {
             let s = 0;
             // Phase 1: exact ID match (v2.11)
-            const idMatch = t.match(idRegex);
+            const idMatch = t.match(STABLE_ID_RE);
             if (idMatch) {
                 const candidateId = idMatch[1] + "-" + deriveItemId(c);
                 if (candidateId === t)
@@ -532,7 +714,11 @@ function renderConfusionAlerts(points, state, expandAll) {
         { keyword: "objective", label: "Loop Objective", ref: "## Loop Objective" },
         { keyword: "loop", label: "Loop Summary", ref: "## Loop Summary" },
     ];
-    const shown = expandAll ? points : points.slice(0, 1);
+    // v2.14: L2 renders up to the policy cap (was: every confusion point,
+    // unbounded by max_confusion_points); L1 keeps a single alert.
+    const shown = expandAll
+        ? points.slice(0, getPolicy().prompt.max_confusion_points)
+        : points.slice(0, 1);
     for (const point of shown) {
         const truncated = point.length > 200 ? point.slice(0, 197) + "…" : point;
         // Find best-matching state section
@@ -545,7 +731,7 @@ function renderConfusionAlerts(points, state, expandAll) {
                 bestSection = sec;
             }
         }
-        const pointer = bestSection && bestScore >= 0.15
+        const pointer = bestSection && bestScore >= getPolicy().prompt.confusion_section_threshold
             ? `→ Check **${bestSection.label}** (\`${bestSection.ref}\`) in the state file.`
             : "→ Read the full state file for relevant context.";
         lines.push(`- **"${truncated}"**`);
@@ -581,14 +767,20 @@ function renderCriticalContext(emphasized, state) {
 function renderExpandedSection(sectionName, state) {
     switch (sectionName) {
         case "milestones": {
-            if (state.phaseHistory.length === 0)
+            if (state.milestones.length === 0)
                 return "";
-            const text = state.phaseHistory
-                .map((phase) => {
-                const range = phase.closedAtRound
-                    ? `R${phase.enteredAtRound}-R${phase.closedAtRound}`
-                    : `R${phase.enteredAtRound}-current`;
-                return `**${phase.label}** (${range}, ${phase.status})\n  Outcome: ${phase.outcome}`;
+            const text = state.milestones
+                .map((m) => {
+                const icon = m.kind === "agent_declared" ? "🏁" : m.kind === "criteria_milestone" ? "✅" : "📍";
+                const lines = [
+                    `**${icon} ${m.label}** (R${m.round_range.start}–R${m.round_range.end}, ${(m.progress_at_boundary * 100).toFixed(0)}%)`,
+                    `  Outcome: ${m.outcome}`,
+                ];
+                if (m.carried_constraints.length > 0)
+                    lines.push(`  Carried: ${m.carried_constraints.slice(0, 3).join("; ")}`);
+                if (m.resolved_constraints.length > 0)
+                    lines.push(`  Resolved: ${m.resolved_constraints.slice(0, 3).join("; ")}`);
+                return lines.join("\n");
             })
                 .join("\n\n");
             return section("Expanded Phase History", text);
@@ -686,7 +878,6 @@ export function assemblePromptArtifact(input) {
     // than relying on potentially-compacted conversation history.
     const fullContextReasons = new Set([
         "first_round", "plan_boundary", "checkpoint_boundary", "goal_changed",
-        "constraint_changed",
         "missing_previous_state", "verification_contradicted",
         "rejection_rehydrate", "recovery_boundary", "state_drift",
         "periodic_refresh",
@@ -695,8 +886,13 @@ export function assemblePromptArtifact(input) {
         || input.mode === "pointer"
         || input.reasons.some((r) => fullContextReasons.has(r));
     const stateFilePath = input.state.stateFilePath;
+    // v3.2: L1 annotates the pointer with the round the freshly-regenerated
+    // state file describes (it is rewritten every compile); L0/L2 keep the
+    // plain pointer byte-identical.
     const stateFileRef = stateFilePath
-        ? `📄 Full state: \`${stateFilePath}\`\n`
+        ? (input.level === "l1"
+            ? `📄 Full state: \`${stateFilePath}\` (updated round ${input.state.round})\n`
+            : `📄 Full state: \`${stateFilePath}\`\n`)
         : "";
     const readInstruction = needsFullContext && stateFilePath
         ? [
@@ -716,13 +912,11 @@ export function assemblePromptArtifact(input) {
         readInstruction,
         "",
     ].join("\n");
-    const sections = selectSections(input);
     const pointer = stateFilePath
         ? section("Full State", stateFilePath)
         : "";
-    const reportBlock = input.roundReportBlock ?? "";
-    const evaluation = reportBlock.trim()
-        ? `${reportBlock.trim()}\n`
+    const evaluation = input.selfEvaluationBlock.trim()
+        ? `${input.selfEvaluationBlock.trim()}\n`
         : "";
     const howToRespond = [
         "## How to Complete This Round",
@@ -730,20 +924,24 @@ export function assemblePromptArtifact(input) {
         "1. Execute the task described above. Do NOT generate another prompt or plan — act.",
         "2. When finished, call the MCP tool **`loopforge_next`** with these parameters:",
         "   - `sessionId`: the session ID from `loopforge_start`.",
-        "   - `report`: a canonical `RoundReport` object (see schema below).",
+        "   - `evaluation`: a structured self-assessment object (see schema below).",
         "",
         "### Evaluation Rules",
         "",
-        "- Use `outcome=success` only when all criteria have runtime-verified evidence; use `continuation=stop` only when you are requesting no further round.",
-        "- `violations`: list every constraint actually violated.",
-        "- Put claims in `evidence.claims` and reference configured providers or commands through `evidenceRefs`; provenance is runtime-owned.",
-        "- Do not estimate progress. LoopForge derives it from verified claims and remaining criteria.",
+        "- `success`: Set to **`true` ONLY** when ALL hard constraints are met AND",
+        "  the task goal is fully achieved. If anything remains incomplete, set `false`.",
+        "- `should_continue`: Set to **`false` ONLY** when the ENTIRE loop task is done.",
+        "  Partial progress or completed subtasks → `true`.",
+        "- `constraint_violations`: Be honest. List every constraint you actually violated.",
+        "- `execution_evidence.files_changed`: List files you modified — used for verification.",
+        "- `execution_evidence.test_results`: Report actual test runner output.",
+        "- `progress_estimate`: A number 0.0–1.0 reflecting overall task completion.",
         "",
         "### If the Prompt Says \"REJECTED\"",
         "",
         "- Re-execute the **same round**. Do NOT advance the round counter.",
         "- Read the Required Fix section, address every issue, then submit again.",
-        "- Use `loopforge_next` with a corrected report.",
+        "- Use `loopforge_next` with a corrected evaluation.",
         "",
         evaluation,
     ].join("\n");
@@ -768,7 +966,45 @@ export function assemblePromptArtifact(input) {
             ...input.state.changesSinceLastRound,
         ], emphasizeCap)
         : [];
+    // v2.14: emphasize is a pure reorder (zero token overhead) — the matched
+    // items are MOVED to the Critical Context section, not duplicated. Filter
+    // them out of the source arrays before section rendering; unmatched
+    // emphasizes are dropped (nothing to reorder → nothing rendered).
+    // v3.2.1: hard constraints and success criteria live in BOTH their own
+    // sections (Active Hard Constraints / Success Criteria) and the active
+    // constraint list (loop-compiler merges objective.hard_constraints and
+    // success_criteria into constraints_active), so they must be filtered
+    // from BOTH sources too — otherwise the emphasized item renders twice.
+    const emphasizedSet = new Set(emphasized);
+    const stateForSections = emphasizedSet.size > 0
+        ? {
+            ...input.state,
+            activeConstraints: input.state.activeConstraints.filter((item) => !emphasizedSet.has(item)),
+            hardConstraints: input.state.hardConstraints.filter((item) => !emphasizedSet.has(item)),
+            successCriteria: input.state.successCriteria.filter((item) => !emphasizedSet.has(item)),
+            discoveries: input.state.discoveries.filter((item) => !emphasizedSet.has(item)),
+            blockers: input.state.blockers.filter((item) => !emphasizedSet.has(item)),
+            changesSinceLastRound: input.state.changesSinceLastRound.filter((item) => !emphasizedSet.has(item)),
+        }
+        : input.state;
+    const sections = selectSections({ ...input, state: stateForSections }, emphasizedSet);
     const criticalContextText = renderCriticalContext(emphasized, input.state);
+    // v3.2: L1 only — snapshot what this prompt actually presented, so the
+    // NEXT L1 compile can diff against it (persisted via PromptArtifact →
+    // lineage). L0/L2 leave it undefined: their presentation semantics differ
+    // (L2's dashboard includes done/canceled sub-goals, which would
+    // contaminate the L1 active-set diff).
+    let presentedState;
+    if (levelIsL1) {
+        const activeSubsForSnapshot = stateForSections.subGoals.filter((sg) => sg.status === "in_progress" || sg.status === "pending");
+        presentedState = {
+            round: input.state.round,
+            constraintIds: activeNonHardConstraints(stateForSections)
+                .map((text) => constraintIdOf(text, stateForSections.constraintMetadata)),
+            subGoals: activeSubsForSnapshot.map((sg) => [sg.id, sg.status]),
+            milestoneRanges: input.state.milestones.map((m) => [m.round_range.start, m.round_range.end]),
+        };
+    }
     // Expand: L1 only, max 1 section (L2 already expanded, L0 ignored)
     const expandCap = levelIsL1 ? policy.max_expand_l1 : 0;
     const expandedSection = (pr?.expand?.length && expandCap > 0)
@@ -802,7 +1038,7 @@ export function assemblePromptArtifact(input) {
     ];
     const promptHash = createHash("sha256").update(renderedPrompt).digest("hex");
     return {
-        format: PROMPT_ARTIFACT_FORMAT,
+        schemaVersion: PROMPT_ARTIFACT_SCHEMA_VERSION,
         roundId: `loop:${input.state.loopId}:round:${input.state.round}`,
         attempt,
         level: input.level,
@@ -812,18 +1048,11 @@ export function assemblePromptArtifact(input) {
         stateHash,
         basePromptVersion: BASE_PROMPT_VERSION,
         includedSections,
-        omittedSections: selected.omitted,
         budgetChars: budget,
         charCount: renderedPrompt.length,
         budgetExceeded: renderedPrompt.length > budget,
-        // lastL2Round / lastMeaningfulProgressRound / stateAgeRounds are NOT
-        // assembled here: the assembler has no vault history and can only guess,
-        // so the values were always immediately overwritten by the compiler's
-        // vault-derived backfill. They stay undefined at this layer.
-        phaseId: input.state.phaseHistory.at(-1)?.id,
-        focusId: input.state.todoProjection?.sourceId,
-        todoId: input.state.todoProjection?.id,
         generatedAt: Date.now(),
+        ...(presentedState ? { presentedState } : {}),
     };
 }
 //# sourceMappingURL=prompt-assembler.js.map