loopforge 3.0.0 → 3.6.0

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 { buildRoadmap, hashCanonicalState, milestoneHeading, trustBarLine } from "./canonical-state.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,97 @@ 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.3.1: Render an identity-HETEROGENEOUS list — the merged active
+ *  constraint set holds hard/plan/criteria/discovered texts together, so no
+ *  single prefix fits. Each item's authoritative ID comes from constraint
+ *  metadata (criteria texts carry cr-XXXXXXXX, everything else
+ *  c-XXXXXXXX), keeping the active list in the same identity namespace as
+ *  the item's own section — one text never renders under two prefixes in
+ *  one prompt. Falls back to a c- derivation only when metadata is missing
+ *  (defensive: metadata covers every active text by construction). */
+function bulletsWithIdentities(values, metadata) {
+    const idEnabled = getPolicy().evolution.constraint_id_enabled;
+    if (!idEnabled)
+        return bullets(values);
+    const idByText = new Map(metadata.map((meta) => [meta.text, meta.id]));
+    return values.map((v) => {
+        const trimmed = v.trim();
+        if (STABLE_ID_RE.test(trimmed)) {
+            return `- [\`${trimmed}\`] ${trimmed}`;
+        }
+        const id = idByText.get(trimmed) ?? `c-${deriveItemId(trimmed)}`;
+        return `- [\`${id}\`] ${trimmed}`;
+    }).join("\n");
+}
+/** 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 every CHECK_* constant is enforced by a test that
+ *  iterates the verification-gate module's CHECK_ exports (no hardcoded
+ *  list — a new constant can never silently lack an action entry). */
+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.",
+    // v3.3 — Round Contract checks (and the three v3.3 checks that predated
+    // this table entry and fell back to the generic action).
+    verification_entrypoint_modified: "Re-run the verification command on the changed entrypoint, or revert the entrypoint change and re-run.",
+    test_files_modified: "Re-run the verification command after the test-file changes and report the fresh output.",
+    round_underspecified: "Declare this round's contract with a non-empty done_when list — what must be true when the round is done?",
+    round_unverifiable: "Name only configured, enabled evidence.commands in verification_plan, or drop done_when items that cannot be machine-verified.",
+    round_scope_drift: "Revert the out-of-scope file changes, or extend the contract scope to cover them and explain why in drift_clarification.",
+    premature_boundary: "Run the contract's verification_plan commands and report real output before claiming done_when met; or set success=false and list the items in success_criteria_remaining (no_change_reason does not apply to contract claims).",
+    // v3.5 — contract completion machine-backing + premature-replacement warn
+    contract_completion_unverified: "Completion under the ACTIVE Round Contract requires its verification_plan commands to pass this round — fix the underlying failure so they pass and resubmit. Completion claims are not accepted without machine verification (no_change_reason does not apply).",
+    contract_premature: "The ACTIVE contract is still open — restate it unchanged to continue it; a different contract is ignored until the active one is completed or blocked.",
+};
+/** 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 +131,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 +215,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 +232,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 +263,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 +274,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", bulletsWithIdentities(active, state.constraintMetadata)),
+                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 +316,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 +365,72 @@ 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: "external_context",
+            text: section("External Context", state.externalContext),
+            mandatory: false,
+        });
+    }
+    // v3.3: Forward-looking roadmap (same buildRoadmap as state.md and L2).
+    const roadmapLines = buildRoadmap(state);
+    if (roadmapLines.length > 0) {
         sections.push({
-            id: "rolling_outcomes",
-            text: section("Recent Rounds", bullets(state.rollingOutcomes)),
+            id: "roadmap",
+            text: section("Roadmap", roadmapLines.join("\n")),
             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 +438,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,36 +454,71 @@ 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],
         ["failed_patterns", "Failed Patterns", state.failedPatterns, null],
     ];
     for (const [id, title, values, idPrefix] of groups) {
-        if (values.length > 0) {
-            const body = idPrefix
+        if (values.length === 0)
+            continue;
+        // v3.3.1: the active set is identity-heterogeneous (hard/plan/criteria/
+        // discovered merged) — render through constraint metadata so criteria
+        // texts keep their cr- identity here too (same namespace as their own
+        // Success Criteria section). Every other group is homogeneous and keeps
+        // its single-prefix renderer.
+        const body = id === "active_constraints"
+            ? bulletsWithIdentities(values, state.constraintMetadata)
+            : 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 });
+    }
+    // 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.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.3: Forward-looking roadmap — rendered right before the (backward-
+    // looking) Phase History so the agent sees where it is before where it's
+    // been. Same buildRoadmap as state.md and L1.
+    const roadmapLines = buildRoadmap(state);
+    if (roadmapLines.length > 0) {
+        sections.push({
+            id: "roadmap",
+            text: section("Roadmap", roadmapLines.join("\n")),
+            mandatory: false,
+        });
+    }
+    if (state.milestones.length > 0) {
+        const milestoneText = state.milestones
+            .map((m) => {
+            const lines = [
+                milestoneHeading(m),
+                `  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,
         });
     }
@@ -332,17 +566,10 @@ function l2Sections(state, fullStateMarkdown) {
             mandatory: false,
         });
     }
-    if (state.loopSynthesis) {
-        sections.push({
-            id: "loop_synthesis",
-            text: section("Loop Summary", state.loopSynthesis),
-            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,
         });
     }
@@ -359,7 +586,8 @@ function l2Sections(state, fullStateMarkdown) {
         state.progress.criteriaMet.length > 0 ||
         state.progress.criteriaRemaining.length > 0 ||
         state.progress.filesChanged.length > 0 ||
-        state.progress.tests !== null) {
+        state.progress.tests !== null ||
+        state.machineStatus !== undefined) {
         const lines = [];
         const total = state.progress.criteriaMet.length + state.progress.criteriaRemaining.length;
         if (total > 0) {
@@ -367,6 +595,22 @@ function l2Sections(state, fullStateMarkdown) {
         }
         if (state.progress.estimate !== null) {
             lines.push(`**Estimated Completion**: ${(state.progress.estimate * 100).toFixed(0)}%`);
+            // v3.3: honest labeling — the estimate is the agent's own number.
+            lines.push("**Signal source**: self-reported estimate (unverified until machine-backed)");
+        }
+        // v3.3: machine side of the comparison — git motion over committed
+        // rounds (v3.6: the object always carries definite values — no
+        // "unavailable" arm).
+        if (state.machineStatus) {
+            const ms = state.machineStatus;
+            const motion = ms.gitMotion
+                ? `changes in ${ms.motionRounds}/${ms.windowRounds} recent committed rounds`
+                : `no git changes in the last ${ms.windowRounds} committed rounds`;
+            lines.push(`**Machine (git)**: ${motion}`);
+        }
+        if (state.criterionStatuses.length > 0) {
+            const metCount = state.criterionStatuses.filter((cs) => cs.status === "met").length;
+            lines.push(`**Machine (criteria)**: ${metCount}/${state.criterionStatuses.length} met across committed rounds`);
         }
         if (state.progress.tests) {
             lines.push(`**Tests**: ${state.progress.tests.passed} passed, ` +
@@ -380,12 +624,54 @@ 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")),
             mandatory: false,
         });
     }
+    // v3.3: Per-round statistics — lets the agent calibrate round granularity
+    // (files per round, rejected attempts, self-reported progress deltas).
+    // v3.6: source-labeled — files/Δ are agent-reported; only rejected
+    // attempts (and the Machine (git) row above) are machine-recorded.
+    if (state.roundStats && state.roundStats.length > 0) {
+        const statLines = state.roundStats.map((stat) => {
+            const parts = [];
+            if (stat.filesChangedCount !== null) {
+                parts.push(`${stat.filesChangedCount} file${stat.filesChangedCount === 1 ? "" : "s"}`);
+            }
+            if (stat.rejectedAttempts !== null && stat.rejectedAttempts > 0) {
+                parts.push(`${stat.rejectedAttempts} rejected attempt${stat.rejectedAttempts === 1 ? "" : "s"}`);
+            }
+            if (stat.progressDelta !== null) {
+                parts.push(`Δ${stat.progressDelta >= 0 ? "+" : ""}${stat.progressDelta.toFixed(2)}`);
+            }
+            return `- R${stat.round}: ${parts.length > 0 ? parts.join(", ") : "no data"}`;
+        });
+        statLines.push("> files & Δ are agent-reported; rejected attempts are machine-recorded " +
+            "(the Machine (git) row above is machine-observed)");
+        sections.push({
+            id: "round_stats",
+            text: section("Round Stats", statLines.join("\n")),
+            mandatory: false,
+        });
+    }
     // Retired Constraints
     if (state.retiredConstraints.length > 0) {
         const lines = state.retiredConstraints.map((c) => `- ~${c}~ (retired)`);
@@ -419,11 +705,8 @@ function l2Sections(state, fullStateMarkdown) {
     }
     // Agent Trust Score + Trend
     if (state.agentTrustScore !== undefined) {
-        const barLen = 10;
-        const filled = Math.round(state.agentTrustScore * barLen);
-        const bar = "█".repeat(filled) + "░".repeat(barLen - filled);
         const lines = [
-            `${bar} ${(state.agentTrustScore * 100).toFixed(0)}%`,
+            trustBarLine(state.agentTrustScore),
         ];
         if (state.agentTrustTrend.length > 0) {
             const avg = (state.agentTrustTrend.reduce((a, b) => a + b, 0)
@@ -439,27 +722,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 +745,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 +758,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)
@@ -511,7 +785,7 @@ function matchEmphasize(targets, candidates, cap) {
 }
 /** Render the "Confusion Alerts" section that appears at the prompt top.
  *  Compiler auto-matches each confusion point against state sections. */
-function renderConfusionAlerts(points, state, expandAll) {
+function renderConfusionAlerts(points, state, fullDensity) {
     if (points.length === 0)
         return "";
     const lines = [
@@ -530,9 +804,12 @@ function renderConfusionAlerts(points, state, expandAll) {
         { keyword: "criteria", label: "Success Criteria", ref: "## Success Criteria" },
         { keyword: "phase", label: "Phase History", ref: "## Phase History" },
         { 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 = fullDensity
+        ? 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,14 +822,14 @@ 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}"**`);
         lines.push(`  ${pointer}`);
         lines.push("");
     }
-    if (!expandAll && points.length > 1) {
+    if (!fullDensity && points.length > 1) {
         lines.push(`*… and ${points.length - 1} more confusion point(s) — see state file.*`);
         lines.push("");
     }
@@ -575,105 +852,6 @@ function renderCriticalContext(emphasized, state) {
     lines.push("");
     return lines.join("\n");
 }
-/** Expand a specific section to L2-level detail within a L1 prompt.
- *  Returns the expanded section text, or empty string if the section
- *  has no content to expand. */
-function renderExpandedSection(sectionName, state) {
-    switch (sectionName) {
-        case "milestones": {
-            if (state.phaseHistory.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}`;
-            })
-                .join("\n\n");
-            return section("Expanded Phase History", text);
-        }
-        case "sub_goals": {
-            if (state.subGoals.length === 0)
-                return "";
-            const lines = [];
-            for (const sg of state.subGoals) {
-                const icon = sg.status === "in_progress" ? "🔄" :
-                    sg.status === "done" ? "✅" :
-                        sg.status === "blocked" ? "🚫" :
-                            sg.status === "canceled" ? "❌" : "⏳";
-                const stale = sg.status === "pending" && state.round - sg.declared_at_round >= 10 ? " ⚠️ stale" : "";
-                const detail = sg.status === "done" && sg.completed_at_round
-                    ? ` (done, R${sg.completed_at_round})`
-                    : sg.status === "in_progress" ? ` (since R${sg.status_changed_at_round})`
-                        : sg.status === "pending" ? ` (since R${sg.declared_at_round})`
-                            : sg.status === "blocked" ? ` (blocked R${sg.status_changed_at_round})`
-                                : ` (canceled R${sg.status_changed_at_round})`;
-                lines.push(`- ${icon} [\`${sg.id}\`] ${sg.description}${detail}${stale}`);
-            }
-            return section("Expanded Sub-Goal Dashboard", lines.join("\n"));
-        }
-        case "constraint_lifecycle": {
-            if (state.inactiveConstraints.length === 0 && state.retiredConstraints.length === 0)
-                return "";
-            const lines = [];
-            if (state.inactiveConstraints.length > 0) {
-                lines.push("**Inactive (auto-decayed):**");
-                for (const c of state.inactiveConstraints) {
-                    const meta = state.constraintMetadata.find((m) => m.text === c);
-                    const age = meta ? state.round - (meta.last_violated_at_round || meta.discovered_at_round || 0) : "?";
-                    lines.push(`- ${c} (${age} rounds inactive)`);
-                }
-            }
-            if (state.retiredConstraints.length > 0) {
-                lines.push("**Retired:**");
-                for (const c of state.retiredConstraints)
-                    lines.push(`- ~${c}~`);
-            }
-            return section("Constraint Lifecycle", lines.join("\n"));
-        }
-        case "agent_trust": {
-            if (state.agentTrustScore === undefined)
-                return "";
-            const barLen = 10;
-            const filled = Math.round(state.agentTrustScore * barLen);
-            const bar = "█".repeat(filled) + "░".repeat(barLen - filled);
-            const lines = [
-                `${bar} ${(state.agentTrustScore * 100).toFixed(0)}%`,
-            ];
-            if (state.agentTrustTrend.length > 0) {
-                lines.push(`Trend: ${state.agentTrustTrend.join(" → ")}`);
-            }
-            return section("Agent Trust (Expanded)", lines.join("\n"));
-        }
-        case "progress": {
-            const p = state.progress;
-            if (p.estimate === null && p.criteriaMet.length === 0 && p.criteriaRemaining.length === 0)
-                return "";
-            const lines = [];
-            const total = p.criteriaMet.length + p.criteriaRemaining.length;
-            if (total > 0)
-                lines.push(`**Criteria**: ${p.criteriaMet.length}/${total} met`);
-            if (p.estimate !== null)
-                lines.push(`**Estimate**: ${(p.estimate * 100).toFixed(0)}%`);
-            if (p.tests)
-                lines.push(`**Tests**: ${p.tests.passed} passed, ${p.tests.failed} failed, ${p.tests.skipped} skipped`);
-            if (p.filesChanged.length > 0) {
-                lines.push("**Files Changed**:");
-                for (const f of p.filesChanged.slice(0, 10))
-                    lines.push(`- ${f}`);
-            }
-            return section("Progress Dashboard (Expanded)", lines.join("\n"));
-        }
-        case "loop_synthesis": {
-            if (!state.loopSynthesis)
-                return "";
-            return section("Loop Summary", state.loopSynthesis);
-        }
-        default:
-            return "";
-    }
-}
 export function assemblePromptArtifact(input) {
     const mode = input.mode ?? "adaptive";
     const budgets = { ...DEFAULT_PROMPT_BUDGETS, ...input.budgets };
@@ -686,7 +864,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 +872,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 +898,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 +910,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,12 +952,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);
-    // 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)
-        ? renderExpandedSection(pr.expand[0], 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]),
+        };
+    }
     // Inject confusion alerts into the header area (before mandatory sections)
     const fixedText = header + confusionText;
     // Inject critical context as a mandatory section
@@ -790,19 +1007,18 @@ export function assemblePromptArtifact(input) {
     }
     const selected = mode === "pointer"
         ? renderWithinBudget(augmentedSections.filter((item) => item.mandatory), fixedText, budget)
-        : renderWithinBudget(augmentedSections, fixedText, budget - footer.length - expandedSection.length);
-    const renderedPrompt = selected.rendered + expandedSection + footer;
+        : renderWithinBudget(augmentedSections, fixedText, budget - footer.length);
+    const renderedPrompt = selected.rendered + footer;
     const includedSections = [
         ...selected.included,
         ...(confusionText ? ["confusion_alerts"] : []),
         ...(criticalContextText ? ["critical_context"] : []),
-        ...(expandedSection ? [`expand:${pr?.expand?.[0] ?? ""}`] : []),
         ...(pointer ? ["state_pointer"] : []),
         ...(evaluation ? ["self_evaluation"] : []),
     ];
     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 +1028,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