loopforge 2.11.0 → 3.2.1

package/dist/prompt-assembler.js

@@ -6,7 +6,7 @@
  */
 import { createHash } from "node:crypto";
 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_SCHEMA_VERSION = 1;
 export const BASE_PROMPT_VERSION = "2.0.0";
@@ -23,10 +23,6 @@ function bullets(values, prefix = "- ") {
 }
 /** v2.11: Derive a stable item ID from text content.
  *  Same hash strategy as computeGoalTextHash in loop-compiler.ts. */
-function deriveItemId(text) {
-    const normalized = text.trim().replace(/\s+/g, " ").toLowerCase();
-    return createHash("sha256").update(normalized).digest("hex").slice(0, 8);
-}
 /** v2.11: Render a bullet list with ID prefixes for constraints/criteria.
  *  Each item gets a [prefix-XXXXXXXX] tag. Items that already look like IDs
  *  are rendered as-is. When constraint_id_enabled is false, renders plain bullets. */
@@ -34,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.");
@@ -60,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) {
@@ -89,7 +200,7 @@ level) {
     if (state.verificationFlags.length > 0) {
         sections.push({
             id: "verification",
-            text: section("Verification Gate", verificationText(state)),
+            text: section("Verification Gate", verificationText(state, level)),
             mandatory: true,
         });
     }
@@ -117,9 +228,10 @@ function l0Sections(state) {
     }
     return sections;
 }
-function l1Sections(state) {
+function l1Sections(state, baseline, emphasized) {
     const sections = commonMandatorySections(state, "l1");
     const active = activeNonHardConstraints(state);
+    const collapseEnabled = getPolicy().prompt.l1_collapse_enabled;
     if (state.changesSinceLastRound.length > 0) {
         sections.push({
             id: "changes",
@@ -127,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({
@@ -148,22 +284,44 @@ function l1Sections(state) {
             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({
@@ -172,17 +330,56 @@ 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,
         });
     }
@@ -226,6 +423,24 @@ function l2Sections(state, fullStateMarkdown) {
             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.milestones.length > 0) {
         const milestoneText = state.milestones
             .map((m) => {
@@ -340,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")),
@@ -399,14 +630,15 @@ function l2Sections(state, fullStateMarkdown) {
     }
     return sections;
 }
-function selectSections(input) {
+function selectSections(input, emphasized) {
     if (input.mode === "full") {
         return l2Sections(input.state, input.fullStateMarkdown);
     }
     if (input.level === "l0")
         return l0Sections(input.state);
-    if (input.level === "l1")
-        return l1Sections(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) {
@@ -434,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)
@@ -483,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
@@ -496,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}"**`);
@@ -651,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
         ? [
@@ -672,7 +912,6 @@ export function assemblePromptArtifact(input) {
         readInstruction,
         "",
     ].join("\n");
-    const sections = selectSections(input);
     const pointer = stateFilePath
         ? section("Full State", stateFilePath)
         : "";
@@ -727,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)
@@ -775,6 +1052,7 @@ export function assemblePromptArtifact(input) {
         charCount: renderedPrompt.length,
         budgetExceeded: renderedPrompt.length > budget,
         generatedAt: Date.now(),
+        ...(presentedState ? { presentedState } : {}),
     };
 }
 //# sourceMappingURL=prompt-assembler.js.map