loopforge 3.9.2 → 4.0.7

package/dist/canonical-state.js

@@ -4,11 +4,33 @@
  * consume the same value so they cannot silently drift apart.
  */
 import { createHash } from "node:crypto";
-import { deriveItemId, STABLE_ID_RE, unique } from "./token-utils.js";
+import { deriveCriterionId, deriveItemId, normalizeText, STABLE_ID_RE, unique, uniqueNormalized, } from "./token-utils.js";
 import { claimedMetCriteria, claimedRemainingCriteria } from "./self-eval.js";
 import { getPolicy } from "./policy.js";
 import { deriveConfiguredCapability } from "./policy.js";
-export const CANONICAL_STATE_SCHEMA_VERSION = 1;
+import { formatWorkingMemoryState, hasWorkingMemoryContent, } from "./working-memory.js";
+import { isOpenQuestionId } from "./open-question.js";
+import { MACHINE_EVIDENCE_AUTHORITY, formatEvidencePostureLines, } from "./evidence-posture-view.js";
+import { formatContextBoundaryLabel } from "./round-guidance.js";
+/** v4.0.3: schema 7 adds the previous/retry evidence posture, explicitly split
+ *  reported progress/issues/warnings, compile context and Working Memory
+ *  source counts. v4.0.4: schema 8 records the renamed context vocabulary
+ *  (`fresh_invocation`) in the derived declaration and stateHash. v4.0.5:
+ *  schema 9 adds the optional `currentUserInstruction` projection; schema 10
+ *  (v4.0.6) makes the objective the WORKING objective, falls back to it for
+ *  the Current Task, and removes the Agent-reported test counts. The state
+ *  file is regenerated every round; an older file is a stale view, not a
+ *  legacy document to decode. */
+export const CANONICAL_STATE_SCHEMA_VERSION = 10;
+/** v4.0.5: the ONE wording for "the host supplied no instruction". Prompt and
+ *  state file both render it; neither infers an instruction from the old task
+ *  or transcript. */
+export const CURRENT_USER_INSTRUCTION_NOT_PROVIDED = "not provided for this invocation (the Objective and Current Task remain operative).";
+/** v4.0.5: the protected section's fixed authority note. The instruction is
+ *  invocation input; it never edits the loop's objective or acceptance. */
+export const CURRENT_USER_INSTRUCTION_AUTHORITY = "Host-provided current user instruction for this invocation. It does not " +
+    "rewrite the Objective, Success Criteria, hard constraints, or the Round " +
+    "Contract; a changed objective or acceptance requires a new loop.";
 /** v3.7.1: Presentation view of sub-goals shared by prompts and the state
  *  file (one derivation, no second copy). Only ACTIVE items render as rows
  *  — pending/in_progress/blocked — ordered blocked → in_progress → pending
@@ -31,6 +53,97 @@ export function activeSubGoalView(subGoals, cap) {
         total: subGoals.length,
     };
 }
+export function partitionActiveConstraints(state) {
+    const criteriaKeys = new Set(state.successCriteria.map((text) => normalizeText(text)));
+    const hardKeys = new Set(state.hardConstraints.map((text) => normalizeText(text)));
+    const hard = [];
+    const other = [];
+    for (const text of state.activeConstraints) {
+        const key = normalizeText(text);
+        if (criteriaKeys.has(key))
+            continue;
+        if (hardKeys.has(key))
+            hard.push(text);
+        else
+            other.push(text);
+    }
+    return { criteria: [...state.successCriteria], hard, other };
+}
+function criterionIcon(status) {
+    switch (status) {
+        case "verified": return "✅";
+        case "claimed": return "🟡";
+        case "insufficient": return "🟠";
+        case "contradicted": return "⛔";
+        case "remaining": return "⬜";
+        default: return "❔";
+    }
+}
+/** v3.9.4: the ONE criterion row renderer for the normative prompt section.
+ *  It consumes the same `successCriteria`/`criterionStatuses` pair the state
+ *  file and submission boundary use, and reports the exact ids it emitted so
+ *  prompt coverage can prove them. */
+export function formatCriterionRows(statuses, successCriteria) {
+    const byText = new Map(statuses.map((status) => [normalizeText(status.text), status]));
+    const seen = new Set();
+    const lines = [];
+    const ids = [];
+    for (const text of successCriteria) {
+        const status = byText.get(normalizeText(text));
+        const id = status?.id ?? deriveCriterionId(text);
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        ids.push(id);
+        lines.push(`- ${criterionIcon(status?.status ?? "unknown")} [\`${id}\`] ${text}`);
+    }
+    if (lines.length > 0) {
+        // v4.0.3: the icons are meaningless without their provenance.
+        lines.push("> ✅ machine verified · 🟡 Agent claim · 🟠 insufficient · " +
+            "⛔ contradicted · ⬜ Agent-reported remaining · ❔ unknown");
+    }
+    return { lines, ids };
+}
+/** v3.9.4: the ONE active-sub-goal formatter shared by the prompt and the
+ *  state file. Rows past `cap` lose their descriptions but NEVER their ids:
+ *  the overflow line lists every remaining `sg-*`. */
+export function formatActiveSubGoals(subGoals, round, cap = getPolicy().evolution.max_active_subgoals) {
+    const view = activeSubGoalView([...subGoals], Number.POSITIVE_INFINITY);
+    const visible = view.active;
+    const shown = visible.slice(0, Math.max(0, cap));
+    const hidden = visible.slice(shown.length);
+    const lines = [];
+    for (const sg of shown) {
+        const statusIcon = sg.status === "in_progress" ? "🔄" :
+            sg.status === "blocked" ? "🚫" : "⏳";
+        const stale = sg.status === "pending" &&
+            round - sg.declared_at_round >= 10 ? " ⚠️ stale" : "";
+        const detail = sg.status === "in_progress"
+            ? ` (since R${sg.status_changed_at_round})`
+            : sg.status === "pending"
+                ? ` (since R${sg.declared_at_round})`
+                : ` (blocked R${sg.status_changed_at_round})`;
+        lines.push(`- ${statusIcon} [\`${sg.id}\`] ${sg.description}${detail}${stale}`);
+    }
+    if (hidden.length > 0) {
+        lines.push(`- also active (ids only): ${hidden.map((sg) => `\`${sg.id}\``).join(", ")}`);
+    }
+    lines.push(`> ${view.total} total · ${view.activeTotal} active · ` +
+        `${view.done} done · ${view.canceled} canceled`);
+    return { lines, ids: visible.map((sg) => sg.id) };
+}
+/**
+ * The active contract is the Current Task only when the runtime has a
+ * machine-verifiable contract capability and this invocation did not provide
+ * an explicit instruction.  The contract remains a separately rendered
+ * committed fact in every other case; this helper keeps prompt and state-file
+ * projections on the same rule as state construction.
+ */
+export function contractDrivesCurrentTask(state) {
+    return state.roundContract !== undefined &&
+        state.currentUserInstruction === undefined &&
+        state.capability.contractVerificationAvailable;
+}
 // unique() imported from token-utils.ts
 /** Deterministic JSON serialization used by state and prompt hashes. */
 export function stableStringify(value) {
@@ -102,132 +215,132 @@ function addListWithIds(lines, title, values, prefix) {
 function addListWithIdentities(lines, title, values, metadata) {
     if (values.length === 0)
         return;
-    const idByText = new Map(metadata.map((meta) => [meta.text, meta.id]));
+    const metaByText = new Map(metadata.map((meta) => [meta.text, meta]));
     lines.push(`## ${title}`, "");
     for (const value of values) {
         const trimmed = value.trim();
         if (!trimmed)
             continue;
+        const meta = metaByText.get(trimmed);
         if (STABLE_ID_RE.test(trimmed)) {
             lines.push(`- [\`${trimmed}\`] ${trimmed}`);
         }
         else {
-            const id = idByText.get(trimmed) ?? `c-${deriveItemId(trimmed)}`;
-            lines.push(`- [\`${id}\`] ${trimmed}`);
+            const id = meta?.id ?? `c-${deriveItemId(trimmed)}`;
+            const provenance = constraintProvenanceLabel(meta);
+            lines.push(`- [\`${id}\`] ${trimmed}${provenance}`);
         }
     }
     lines.push("");
 }
-/** v3.8.1: the one-line phase position — which phase the loop is in, and how
- *  far the next boundary is.
- *
- *  This is all that survives of v3.3's "roadmap": of its four lines, three
- *  (met/remaining criteria with ids, sub-goal activity) were already rendered
- *  in full by the sections that own them. Returns "" when no milestone exists,
- *  so the caller renders no section at all — bare position is already in the
- *  prompt header.
- *
- *  Shared by the state-file and prompt renderers so they cannot drift apart
- *  (module contract above). Presentation only; never feeds enforcement. */
-export function buildPhaseLine(state) {
-    const lastMilestone = state.milestones.length > 0
-        ? state.milestones[state.milestones.length - 1]
-        : null;
-    // No phase boundary yet → no phase to report. Position alone ("round 3/200")
-    // is already in the prompt header, so rendering it again would be noise.
-    if (!lastMilestone)
+/** v3.9.7: the ONE constraint provenance label shared by the state file and
+ *  the prompt. A discovered/preserved constraint is an Agent report, never a
+ *  machine-verified fact. */
+export function constraintProvenanceLabel(meta) {
+    if (!meta)
         return "";
-    const roundsSince = lastMilestone.round_range.end <= state.round
-        ? state.round - lastMilestone.round_range.end
-        : null;
-    const parts = [
-        `phase "${lastMilestone.label}"`,
-        `round ${state.round}/${state.maxRounds}`,
-    ];
-    if (roundsSince !== null) {
-        parts.push(`${roundsSince} round${roundsSince === 1 ? "" : "s"} since the last boundary`);
+    const round = meta.source_round !== undefined && meta.source_round >= 1
+        ? ` R${meta.source_round}`
+        : "";
+    switch (meta.source) {
+        case "discovered":
+            return ` (Agent-declared${round}; report, not machine-verified)`;
+        case "preserved":
+            return ` (Agent discovery preserved by rollback${round}; report)`;
+        case "plan":
+            return ` (plan/carried${round})`;
+        case "unrecorded":
+            return " (origin not recorded in committed rounds)";
+        default:
+            return "";
     }
-    return parts.join(" · ");
 }
-/** v3.3/v3.4: Render the ACTIVE Round Contract as the Current Task section
- *  body — the single formatting source shared by prompts and the state
- *  file (module contract above). The original objective is NOT here: it
- *  lives in the Objective section. Empty arrays render no line. */
-export function formatRoundContract(contract,
+export function formatRoundContractWithIds(contract,
 /** v3.8: the derived item statuses. When given, each item renders with its
  *  machine status — the agent sees the verification debt in its own task. */
 statuses) {
     const lines = [];
+    const emittedIds = [contract.id];
     const heading = contract.work_item?.trim();
     lines.push(`**${heading || "Round Contract"}** (${contract.id})`);
     const statusById = new Map((statuses?.items ?? []).map((item) => [item.itemId, item]));
-    for (const item of contract.items) {
+    const items = contract.items;
+    if (items.length > 0) {
+        lines.push("- Acceptance conditions:");
+    }
+    for (const item of items) {
+        emittedIds.push(item.id);
         const machine = statusById.get(item.id);
         const mark = machine?.status === "verified" ? "✅"
             : machine?.status === "insufficient" ? "🟠"
                 : machine?.status === "contradicted" ? "⛔"
                     : machine?.status === "pending" ? "⬜"
                         : "";
-        lines.push(`- ${mark ? `${mark} ` : ""}[\`${item.id}\`] ${item.description}${machine ? ` — ${machine.status}` : ""}`);
+        const status = machine ? ` — ${machine.status}` : "";
+        lines.push(`  - ${mark ? `${mark} ` : ""}[\`${item.id}\`] ${item.description}${status}`);
         if (item.verify_with.length > 0) {
-            lines.push(`  - Verify via: ${item.verify_with.join(", ")}`);
+            lines.push(`    - Verify via: ${item.verify_with.join(", ")}`);
         }
-        if (item.criterion_refs.length > 0) {
-            lines.push(`  - Criteria: ${item.criterion_refs.join(", ")}`);
+        if ((item.criterion_refs ?? []).length > 0) {
+            lines.push(`    - Criteria: ${(item.criterion_refs ?? []).join(", ")}`);
         }
         if (machine?.reasons.length) {
-            lines.push(`  - Unverified because: ${machine.reasons[0]}`);
+            lines.push(`    - Unverified because: ${machine.reasons[0]}`);
         }
     }
-    for (const entry of contract.scope) {
-        lines.push(`- Scope: ${entry}`);
+    if (contract.scope.length > 0) {
+        // v3.9.9: scope is the Agent's declared intent, not a permission.
+        lines.push("- Declared scope (Agent report; not enforced):");
+        for (const entry of contract.scope) {
+            lines.push(`  - ${entry}`);
+        }
     }
-    return lines.join("\n");
+    return { text: lines.join("\n"), emittedIds };
 }
-// ═══════════════════════════════════════════════════════════════════════════
-// v3.3.1: Shared presentation atoms
-// ═══════════════════════════════════════════════════════════════════════════
-/** Milestone heading line ("**🏁 Round 7** (Rounds 3–7)"). Shared by the
- *  L2 Phase History and the detailed L1 renderer; the L1 copy previously
- *  rendered the range as "R3–R7", a format only this heading used. */
-export function milestoneHeading(milestone) {
-    const kindIcon = milestone.kind === "agent_declared"
-        ? "🏁"
-        : milestone.kind === "criteria_milestone" ? "✅" : "📍";
-    return `**${kindIcon} ${milestone.label}** (Rounds ${milestone.round_range.start}–${milestone.round_range.end})`;
+/** Backwards-compatible text-only view used by the state file. */
+export function formatRoundContract(contract, statuses) {
+    return formatRoundContractWithIds(contract, statuses).text;
 }
 const STATE_SECTION_TIER = {
     // Current — what the next round must hold in working memory.
     "Loop Objective": "Current",
     "Current Task": "Current",
+    "Active Round Contract": "Current",
+    "Current User Instruction": "Current",
     "Success Criteria": "Current",
     "Hard Constraints": "Current",
     "Active Constraints": "Current",
-    Remaining: "Current",
-    Blockers: "Current",
+    // v4.0.3: Agent-reported blockers and remaining claims are one report
+    // surface; compile warnings are a separate machine/compile surface.
+    "Agent-Reported Blockers": "Current",
+    "Agent-Reported Remaining Criteria": "Current",
+    "Agent-Reported Resolutions": "Recent",
     "Sub-Goal Dashboard": "Current",
-    "External Context": "Current",
     // v3.8.1: the one-line phase position (the only fact the deleted Roadmap
     // section carried that no other section renders). It is orientation for the
     // NEXT round, so it belongs with the working-memory tier — and it must be
     // listed here at all: an unlisted title is not a heading, so `## Phase` was
     // absorbed into whatever section happened to precede it (its body even kept
     // a raw `## ` line) and inherited that section's tier.
-    Phase: "Current",
     // Recent — this round's boundary facts (and, in a recovery window, the
     // derived Recovery Brief injected at the top of this tier).
     "Progress Dashboard": "Recent",
     Verification: "Recent",
-    "Changes Since Last Round": "Recent",
-    Discoveries: "Recent",
+    // v4.0.3: the retry/governance facts and machine evidence live next to the
+    // round boundary they describe.
+    "Retry Requirements": "Recent",
+    "Compile Warnings": "Recent",
+    "Machine Evidence": "Recent",
+    "Rejected Attempt Evidence": "Recent",
+    // v4.0.2: bounded committed working memory. It replaces the former
+    // Corrections/Discoveries sections; discovered constraints remain visible
+    // through active-constraint provenance.
+    "Working Memory": "Recent",
     // Historical Summary — the loop's memory skeleton, kept under existing
     // milestone/window caps.
     "Goal → Criteria": "Historical Summary",
-    "Cross-Round Outcomes": "Historical Summary",
     "Recurring Flags": "Historical Summary",
-    "Failed Patterns": "Historical Summary",
     "Retired Constraints": "Historical Summary",
-    "Phase History": "Historical Summary",
 };
 const STATE_TIER_ORDER = ["Current", "Recent", "Historical Summary"];
 /** Human/Agent-readable materialized view. It is always reproducible from the
@@ -237,20 +350,34 @@ const STATE_TIER_ORDER = ["Current", "Recent", "Historical Summary"];
  *  criterion list, round stats, the FULL recurring-flag history and the phase
  *  history. The prompt carries only what the next round needs. */
 export function renderCanonicalStateMarkdown(state, options) {
+    const context = state.context ?? options?.context;
     const preamble = [
         `# LoopForge State — ${state.loopId}`,
         "",
         `**Schema**: ${state.schemaVersion}`,
         `**Round**: ${state.round}/${state.maxRounds}`,
         `**Goal ID**: ${state.goalId}`,
+        ...(state.currentUserInstruction
+            ? []
+            : [`**Current user instruction**: ${CURRENT_USER_INSTRUCTION_NOT_PROVIDED}`]),
+        ...(context
+            ? [
+                `**Context**: ${formatContextBoundaryLabel(context.mode, context.reason, { recoveryBoundary: (state.recoveryBrief?.length ?? 0) > 0 })}, attempt ${context.attempt}`,
+            ]
+            : []),
         "**Derived**: true",
-        `**Source**: round ${state.round} (attempt ${options?.attempt ?? 1})`,
+        `**Source**: round ${state.round} (attempt ${context?.attempt ?? options?.attempt ?? 1})`,
+        "**Authority**: committed typed rounds are the factual source; this file is a derived view.",
+        "**Round commit**: a LoopForge round commit is not a Git commit; it does not verify every workspace change.",
+        "**Evidence**: machine evidence = providers, command observations and verified contract items. Agent reports = outcome/files/claims.",
+        "**Working memory**: bounded; it may be abbreviated; full history via replay/explain or this file when enabled.",
         `**State hash**: ${hashCanonicalState(state).slice(0, 12)}`,
         "",
     ];
     const sections = flatStateSections(state);
-    if (options?.recoveryBrief && options.recoveryBrief.length > 0) {
-        sections.unshift({ title: "Recovery Brief", body: options.recoveryBrief });
+    const recoveryBrief = state.recoveryBrief ?? options?.recoveryBrief;
+    if (recoveryBrief && recoveryBrief.length > 0) {
+        sections.unshift({ title: "Recovery Brief", body: recoveryBrief });
     }
     const byTier = new Map();
     for (const tier of STATE_TIER_ORDER)
@@ -280,42 +407,78 @@ export function renderCanonicalStateMarkdown(state, options) {
 function flatStateSections(state) {
     const lines = [];
     lines.push("## Loop Objective", "", state.objective, "", "## Current Task", "", state.currentTask);
-    // v2.11: Success Criteria and Constraints render with stable IDs for exact agent matching
-    addListWithIds(lines, "Success Criteria", state.successCriteria, "cr");
-    addListWithIds(lines, "Hard Constraints", state.hardConstraints, "c");
-    addListWithIdentities(lines, "Active Constraints", state.activeConstraints, state.constraintMetadata);
-    addList(lines, "Changes Since Last Round", state.changesSinceLastRound);
-    if (state.progress.criteriaMet.length > 0 ||
-        state.progress.criteriaRemaining.length > 0 ||
-        state.progress.filesChanged.length > 0 ||
-        state.progress.tests !== null ||
-        state.machineStatus !== undefined) {
-        const total = state.progress.criteriaMet.length + state.progress.criteriaRemaining.length;
+    if (state.roundContract && !contractDrivesCurrentTask(state)) {
+        lines.push("## Active Round Contract", "", formatRoundContract(state.roundContract, state.contractItemStatuses ?? null));
+    }
+    // The host's invocation instruction renders as its own section only when
+    // it is not already visible in Current Task or Objective.
+    if (state.currentUserInstruction &&
+        state.currentUserInstruction !== state.currentTask.trim() &&
+        state.currentUserInstruction !== state.objective.trim()) {
+        lines.push("## Current User Instruction", "", state.currentUserInstruction, "", `> ${CURRENT_USER_INSTRUCTION_AUTHORITY}`);
+    }
+    // v2.11: Success Criteria and Constraints render with stable IDs for exact
+    // agent matching. v3.9.4: the three groups are the SAME mutually exclusive
+    // partition the prompt uses, so one text never appears with two prefixes.
+    const constraintPartition = partitionActiveConstraints(state);
+    addListWithIds(lines, "Success Criteria", constraintPartition.criteria, "cr");
+    addListWithIdentities(lines, "Hard Constraints", constraintPartition.hard, state.constraintMetadata);
+    addListWithIdentities(lines, "Active Constraints", constraintPartition.other, state.constraintMetadata);
+    if (state.rejectionNotice) {
+        lines.push("## Retry Requirements", "", state.rejectionNotice.trim(), "");
+    }
+    addList(lines, "Compile Warnings", state.warnings);
+    if (state.previousEvidencePosture) {
+        lines.push("## Machine Evidence", "", ...formatEvidencePostureLines(state.previousEvidencePosture), "", `> ${MACHINE_EVIDENCE_AUTHORITY}`, "");
+    }
+    if (state.retryEvidencePosture) {
+        lines.push("## Rejected Attempt Evidence", "", "> Not committed; it exists only for the current retry.", "", ...formatEvidencePostureLines(state.retryEvidencePosture), "");
+    }
+    if (hasWorkingMemoryContent(state.workingMemory)) {
+        const working = formatWorkingMemoryState(state.workingMemory);
+        lines.push("## Working Memory", "", ...working.lines, "");
+    }
+    const reported = state.reportedProgress;
+    const posture = state.previousEvidencePosture;
+    if (reported.criteriaMet.length > 0 ||
+        reported.criteriaRemaining.length > 0 ||
+        reported.filesChanged.length > 0 ||
+        state.machineStatus !== undefined ||
+        posture !== undefined) {
+        const total = reported.criteriaMet.length + reported.criteriaRemaining.length;
         lines.push("## Progress Dashboard", "");
         if (total > 0) {
-            lines.push(`**Criteria**: ${state.progress.criteriaMet.length}/${total}`);
+            lines.push(`**Agent-reported criteria**: ${reported.criteriaMet.length}/${total}`);
+        }
+        if (state.criterionStatuses.length > 0) {
+            const verifiedCount = state.criterionStatuses.filter((criterion) => criterion.status === "verified").length;
+            lines.push(`**Machine-verified criteria**: ${verifiedCount}/${state.criterionStatuses.length}`);
+        }
+        if (reported.filesChanged.length > 0) {
+            lines.push("", "**Agent-reported files**:");
+            for (const file of reported.filesChanged)
+                lines.push(`- ${file}`);
+        }
+        if (posture) {
+            const observed = posture.workspace.status === "observed"
+                ? `${posture.workspace.changedPathCount}`
+                : posture.workspace.status === "unknown" ? "unknown" : "not applicable";
+            lines.push(`**Observed changes (last committed round)**: ${observed}`);
+            lines.push(`**Files reconciliation**: ${posture.files?.reconciliation ?? "not_applicable"}`);
         }
         // 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 observed 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 === "verified" || cs.status === "claimed").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, ` +
-                `${state.progress.tests.failed} failed, ${state.progress.tests.skipped} skipped`);
-        }
-        if (state.progress.filesChanged.length > 0) {
-            lines.push("", "**Files Changed**:");
-            for (const file of state.progress.filesChanged)
-                lines.push(`- ${file}`);
+            const providers = ms.providers.length > 0
+                ? ` (providers: ${ms.providers.join(", ")})`
+                : "";
+            const progress = ms.machineProgress === "changed"
+                ? `changes observed in ${ms.changedRounds}/${ms.windowRounds} recent committed rounds${providers}`
+                : ms.machineProgress === "unknown"
+                    ? `not observable in the last ${ms.windowRounds} committed rounds${providers}`
+                    : `no machine-observed progress in the last ${ms.windowRounds} committed rounds${providers}`;
+            lines.push(`**Machine progress**: ${progress}`);
         }
         lines.push("");
     }
@@ -329,20 +492,35 @@ function flatStateSections(state) {
                         : cs.status === "contradicted" ? "⛔"
                             : cs.status === "remaining" ? "⬜" : "❔";
             const idTag = ` [\`${cs.id}\`]`;
-            const met = cs.met_at_round !== undefined ? ` (met R${cs.met_at_round})` : "";
-            const related = cs.related_subgoal_ids.length > 0
-                ? ` (related: ${cs.related_subgoal_ids.join(", ")})`
-                : "";
-            lines.push(`- ${icon}${idTag} ${cs.text}${met}${related}`);
+            // v4.0.3: the round and the provenance are separate facts. A claimed
+            // row names the latest Agent claim; a verified/contradicted/insufficient
+            // row names the machine round that reached it.
+            const at = cs.status_at_round !== undefined ? ` R${cs.status_at_round}` : "";
+            const label = cs.status === "verified" ? `machine verified${at}`
+                : cs.status === "claimed" ? `agent claim${at}`
+                    : cs.status === "insufficient" ? `machine insufficient${at}`
+                        : cs.status === "contradicted" ? `machine contradicted${at}`
+                            : cs.status === "remaining" ? `agent reported remaining${at}`
+                                : "unknown";
+            lines.push(`- ${icon}${idTag} ${cs.text} (${label})`);
+        }
+        lines.push("");
+    }
+    if (reported.agentReportedRemaining.length > 0) {
+        addListWithIds(lines, "Agent-Reported Remaining Criteria", reported.agentReportedRemaining, "cr");
+    }
+    addList(lines, "Agent-Reported Blockers", state.reportedIssues);
+    if (state.resolvedOpenQuestionIds && state.resolvedOpenQuestionIds.length > 0) {
+        const shown = state.resolvedOpenQuestionIds.slice(0, 6);
+        lines.push("## Agent-Reported Resolutions", "", `- ${state.resolvedOpenQuestionIds.length} open question(s) resolved in the ` +
+            "last committed round (Agent report):", ...shown.map((id) => `  - \`${id}\``));
+        if (state.resolvedOpenQuestionIds.length > shown.length) {
+            lines.push(`  - ... and ${state.resolvedOpenQuestionIds.length - shown.length} more ` +
+                "(replay/explain shows every id)");
         }
         lines.push("");
     }
-    addListWithIds(lines, "Remaining", state.remainingCriteria, "cr");
-    addList(lines, "Blockers", state.blockers);
     const recurring = recurringOnly(state.recurringFlags);
-    addList(lines, "Discoveries", state.discoveries);
-    addList(lines, "Cross-Round Outcomes", state.rollingOutcomes);
-    addList(lines, "Failed Patterns", state.failedPatterns);
     // v3.8.1: ONE recurring-facts section. "Recurring Issues" (the last 5
     // rounds' raw violations, no threshold) and "Lessons Learned" (the whole
     // history, count >= 2) were two windows over one fact set rendered as two
@@ -355,78 +533,40 @@ function flatStateSections(state) {
                 ? "🚫"
                 : flag.kind === "verification_error" ? "⚠️" : "ℹ️";
             const subject = flag.ref ? `${flag.subject} [${flag.ref}]` : flag.subject;
-            lines.push(`- ${icon} ${subject} — ${flag.count}× (R${flag.rounds.join(", R")})`);
+            const source = flag.kind === "constraint_violation"
+                ? "Agent-reported violation"
+                : "machine finding";
+            lines.push(`- ${icon} ${subject} — ${flag.count}× (R${flag.rounds.join(", R")}) — ${source}`);
         }
         if (recurring.length > RECURRING_RENDER_CAP) {
             lines.push(`- ... and ${recurring.length - RECURRING_RENDER_CAP} more`);
         }
         lines.push("");
     }
-    addList(lines, "Retired Constraints", state.retiredConstraints);
-    // v3.8.1: the Roadmap section is gone. Only its non-duplicated fact — the
-    // phase position — survives, as the one-line phase line the prompts render.
-    const phaseLine = buildPhaseLine(state);
-    if (phaseLine) {
-        lines.push("## Phase", "", `- ${phaseLine}`);
+    if (state.retiredConstraints.length > 0) {
+        lines.push("## Retired Constraints", "");
+        for (const constraint of state.retiredConstraints) {
+            lines.push(`- ${constraint} (Agent report)`);
+        }
         lines.push("");
     }
     if (state.verificationFlags.length > 0) {
         lines.push("## Verification", "");
         for (const flag of state.verificationFlags) {
-            lines.push(`- [${flag.severity}] [${flag.check}] ${flag.detail}`);
+            lines.push(`- [${flag.severity}] [${flag.check}] \`${flag.field}\` — ${flag.detail}` +
+                (flag.ref ? ` [ref: \`${flag.ref}\`]` : ""));
         }
         lines.push("");
     }
-    if (state.milestones.length > 0) {
-        lines.push("## Phase History", "");
-        for (const m of state.milestones) {
-            const kindIcon = m.kind === "agent_declared"
-                ? "🏁"
-                : m.kind === "criteria_milestone" ? "✅" : "📍";
-            lines.push(`### ${kindIcon} ${m.label}`, `Rounds ${m.round_range.start}–${m.round_range.end}`, "", `**Outcome**: ${m.outcome}`, "");
-            if (m.carried_constraints.length > 0) {
-                lines.push("**Carried Constraints**:");
-                for (const c of m.carried_constraints)
-                    lines.push(`- ${c}`);
-                lines.push("");
-            }
-            if (m.resolved_constraints.length > 0) {
-                lines.push("**Resolved During Phase**:");
-                for (const c of m.resolved_constraints)
-                    lines.push(`- ${c}`);
-                lines.push("");
-            }
-        }
-    }
     if (state.subGoals.length > 0) {
-        // v3.7.1: only ACTIVE items render as rows; done/canceled survive in
-        // the vault, replay, and the counts line below.
-        const cap = getPolicy().evolution.max_active_subgoals;
-        const view = activeSubGoalView(state.subGoals, cap);
+        // v3.9.4: the SAME formatter the prompt uses. Rows past the display cap
+        // keep their ids in an overflow line, so the state file's active id set
+        // can never be narrower than the prompt's.
         // L8: the heading is emitted whenever sub-goals exist — with every
         // sub-goal terminal (0 active rows) the counts line must still live
         // under its own section instead of leaking into the previous one.
         lines.push("## Sub-Goal Dashboard", "");
-        if (view.active.length > 0) {
-            for (const sg of view.active) {
-                const statusIcon = sg.status === "in_progress" ? "🔄" :
-                    sg.status === "blocked" ? "🚫" : "⏳";
-                const stale = sg.status === "pending" &&
-                    state.round - sg.declared_at_round >= 10 ? " ⚠️ stale" : "";
-                const detail = sg.status === "in_progress"
-                    ? ` (since R${sg.status_changed_at_round})`
-                    : sg.status === "pending"
-                        ? ` (since R${sg.declared_at_round})`
-                        : ` (blocked R${sg.status_changed_at_round})`;
-                lines.push(`- ${statusIcon} [\`${sg.id}\`] ${sg.description}${detail}${stale}`);
-            }
-            lines.push("");
-        }
-        lines.push(`> ${view.total} total · ${view.activeTotal} active · ` +
-            `${view.done} done · ${view.canceled} canceled`, "");
-    }
-    if (state.externalContext) {
-        lines.push("## External Context", "", state.externalContext, "");
+        lines.push(...formatActiveSubGoals(state.subGoals, state.round).lines, "");
     }
     // Split the flat markdown into titled sections for tier grouping. Every
     // builder above emits `## <Title>` headings over their content — but only
@@ -469,32 +609,63 @@ export function createCanonicalLoopState(request, response, stateFilePath,
 /** v3.3: Display-only derived data. Optional 4th param — callers that
  *  predate v3.3 stay on 3-arg calls. */
 derived) {
-    const last = request.last_round_result;
+    const last = derived?.previousRound?.result ?? null;
     const objective = response.loop_objective;
-    const verificationFlags = request.verification_flags ?? [];
-    const rolling = response.rolling_summary;
-    const executionReport = last?.execution_report;
-    const changes = unique([
-        request.new_since_last_round,
-        last?.output_summary,
-        ...(last?.wrong_assumptions ?? []).map((value) => `Corrected assumption: ${value}`),
+    const verificationFlags = derived?.previousRound?.verificationFlags ??
+        request.verification_flags ?? [];
+    // v3.9.5: only committed previous-round reports enter the projection. The
+    // compiler no longer has an uncommitted fallback at all.
+    const committed = derived?.previousRound?.committed === true;
+    // Keep the report projection behind the same boundary as corrections and
+    // blockers.  The fallback result may still be consumed by compiler
+    // evolution, but an uncommitted/rejected attempt cannot become durable
+    // progress, discovery, or criterion state.
+    const executionReport = committed ? last?.execution_report : undefined;
+    // v4.0.3: blockers are Agent reports; warnings are compiler facts. They
+    // were previously merged into one `blockers` list.
+    const reportedIssues = unique([
+        ...(committed ? (last?.constraint_violations ?? []) : []),
+        ...(committed && last?.blocker ? [last.blocker] : []),
     ]);
-    const discoveries = unique([
-        ...(last?.discovered_constraints ?? []),
-        ...(last?.emerged_subtasks ?? []),
-    ]);
-    const blockers = unique([
-        ...(last?.constraint_violations ?? []),
-        last?.manual_fixes_needed,
-        request.rejection_notice,
-        ...response.warnings,
-    ]);
-    // v3.4: The ACTIVE Round Contract (derived — loop-compiler computes it
-    // from committed rounds) drives the Current Task — the contract IS "what
-    // to do this round"; the original objective stays in the Objective
-    // section above. No active contract → the original task text is used,
-    // byte-identical to pre-v3.3 behavior.
+    const warnings = unique(response.warnings);
+    const committedPosture = committed ? derived?.previousRound?.view?.evidencePosture ?? null : null;
+    const retryPosture = request.retry_evidence_posture ?? null;
+    // v4.0.3: the Agent's resolved-question report is bounded and rendered as a
+    // separate provenance line; it never silently disappears into Working
+    // Memory's active-set filtering.
+    const resolvedOpenQuestionIds = committed
+        ? unique(last?.resolved_open_question_ids ?? [])
+            .filter(isOpenQuestionId)
+        : [];
+    // v4.0.6: The Agent still chooses when a round ends. The ACTIVE Round
+    // Contract (derived from committed rounds) supplies the verifiable work
+    // slice for this invocation when verification capability exists. An
+    // explicit invocation instruction has priority; without contract capability
+    // the Current Task falls back to the working objective.
     const roundContract = derived?.roundFacts?.activeContract ?? null;
+    const capability = deriveConfiguredCapability(getPolicy());
+    // v4.0.5: the host's explicit invocation input. Empty/whitespace is "not
+    // provided", never a second task. Conditional presence keeps the state hash
+    // byte-identical when no instruction was given.
+    const currentUserInstruction = request.current_user_instruction?.trim() || undefined;
+    // v3.9.4: the rendered criterion/hard sets are ACTIVE sets. The compile
+    // response's `criterion_statuses` is the active criterion reference space
+    // (loop-compiler filters it); `constraints_active` is the active constraint
+    // set. A direct caller that omits `criterion_statuses` gets the objective
+    // fallback so library-level state construction still works.
+    const activeConstraints = uniqueNormalized(response.constraints_active);
+    const activeConstraintKeys = new Set(activeConstraints.map((text) => normalizeText(text)));
+    const observedCompile = response.criterion_statuses !== undefined;
+    const successCriteria = observedCompile
+        ? uniqueNormalized(response.criterion_statuses.map((criterion) => criterion.text))
+        : uniqueNormalized(objective?.success_criteria ?? []);
+    const criteriaKeys = new Set(successCriteria.map((text) => normalizeText(text)));
+    const hardConstraints = uniqueNormalized(objective?.hard_constraints ?? [])
+        .filter((text) => {
+        const key = normalizeText(text);
+        return !criteriaKeys.has(key) &&
+            (!observedCompile || activeConstraintKeys.has(key));
+    });
     return {
         schemaVersion: CANONICAL_STATE_SCHEMA_VERSION,
         loopId: response.loop_id || request.loop_id,
@@ -502,47 +673,52 @@ derived) {
         maxRounds: request.max_rounds ?? getPolicy().engine.max_rounds,
         goalId: response.goal_id,
         objective: objective?.objective || request.task,
-        objectiveVersion: objective?.version ?? 1,
-        currentTask: roundContract
+        currentTask: currentUserInstruction ?? (roundContract && capability.contractVerificationAvailable
             ? formatRoundContract(roundContract, derived?.roundFacts?.itemStatuses ?? null)
-            : request.task,
-        successCriteria: unique(objective?.success_criteria ?? []),
-        hardConstraints: unique(objective?.hard_constraints ?? []),
-        activeConstraints: unique(response.constraints_active),
+            : objective?.objective ?? request.task),
+        ...(currentUserInstruction ? { currentUserInstruction } : {}),
+        successCriteria,
+        hardConstraints,
+        activeConstraints,
         retiredConstraints: unique(response.constraints_retired),
         constraintMetadata: response.constraint_metadata ?? [],
-        changesSinceLastRound: changes,
-        remainingCriteria: unique(claimedRemainingCriteria(last?.execution_report)),
-        blockers,
+        rejectionNotice: request.rejection_notice.trim() ? request.rejection_notice : null,
+        // v4.0.3: conditional presence keeps hashes stable for a first round.
+        ...(committedPosture ? { previousEvidencePosture: committedPosture } : {}),
+        ...(retryPosture ? { retryEvidencePosture: retryPosture } : {}),
+        reportedIssues,
+        warnings,
         verificationFlags,
-        discoveries,
-        rollingOutcomes: unique(rolling?.key_outcomes ?? []),
-        failedPatterns: unique(rolling?.failed_patterns ?? []),
-        milestones: rolling?.milestones ?? [],
+        // v4.0.2: conditional presence — no committed working memory, no key.
+        ...(hasWorkingMemoryContent(derived?.workingMemory)
+            ? { workingMemory: derived.workingMemory }
+            : {}),
         subGoals: response.sub_goals ?? [],
         criterionStatuses: response.criterion_statuses ?? [],
         recurringFlags: response.recurring_flags ?? [],
-        externalContext: request.external_context?.trim() ?? "",
         stateFilePath,
-        progress: {
+        reportedProgress: {
             criteriaMet: unique(claimedMetCriteria(executionReport)),
             criteriaRemaining: unique(claimedRemainingCriteria(executionReport)),
+            agentReportedRemaining: unique(claimedRemainingCriteria(executionReport)),
             filesChanged: unique(executionReport?.files_changed ?? []),
-            tests: executionReport?.tests_reported ?? null,
         },
+        ...(resolvedOpenQuestionIds.length > 0
+            ? { resolvedOpenQuestionIds }
+            : {}),
+        ...(derived?.context ? { context: derived.context } : {}),
         // v3.3: Conditional presence — empty/absent derived data must not add
         // keys, or every state hash would change for rounds without it.
+        ...(derived?.recoveryBrief && derived.recoveryBrief.length > 0
+            ? { recoveryBrief: [...derived.recoveryBrief] }
+            : {}),
         ...(derived?.machineStatus ? { machineStatus: derived.machineStatus } : {}),
         // v3.3: Conditional presence — no contract, no key (hash stability).
         ...(roundContract ? { roundContract } : {}),
         ...(derived?.roundFacts?.itemStatuses
             ? { contractItemStatuses: derived.roundFacts.itemStatuses }
             : {}),
-        ...(derived?.roundFacts?.verifiedSubGoals &&
-            derived.roundFacts.verifiedSubGoals.length > 0
-            ? { verifiedSubGoals: [...derived.roundFacts.verifiedSubGoals] }
-            : {}),
-        capability: deriveConfiguredCapability(getPolicy()),
+        capability,
     };
 }
 //# sourceMappingURL=canonical-state.js.map