loopforge 2.7.0 → 3.0.0

package/dist/{engine.js → runtime-services.js}

@@ -1,44 +1,42 @@
-/** LoopForge-loop_compile — Engine (outer loop manager).
+/** LoopForge runtime services — stateless compiler, round-event and metrics boundary.
  *
- * 2-mode engine with vault-backed loop lineage persistence.
- * invokeLoopCompile (primary), invokeFeedback.
- * Circuit breaker prevents infinite stall loops.
- * EngineMetrics tracks silent-failure counters for observability.
+ * The public execution path owns session and transaction state; this service
+ * provides the pure compile and round-event operations used by that path.
+ * invokeLoopCompile is the primary operation. RuntimeMetrics tracks
+ * silent-failure counters for observability.
  */
 import { randomUUID } from "node:crypto";
 import { getPolicy } from "./policy.js";
-import { FileLoopStore, LoopStoreBackend } from "./loop-store.js";
-import { AgentStatus, Mode, makeExecutionFeedback, makeLoopCompileRequest, makeLoopObjective, makeLoopRoundResult, makeSessionState, makeTaskId, } from "./protocol.js";
+import { FileLoopStore } from "./loop-store.js";
+import { AgentStatus, Mode, makeLoopCompileRequest, makeLoopObjective, makeSessionState, makeTaskId, } from "./protocol.js";
 import { compileLoop } from "./loop-compiler.js";
 import { logEvent } from "./observability.js";
-import { parseExecutionEvidence, parseCriterionRevisions, parseWorkerResults, } from "./self-eval.js";
+import { policyMetrics } from "./policy-metrics.js";
 import { parseLoopExtras } from "./loop-extras-parser.js";
-// ── Re-export self-evaluation utilities (moved to self-eval.ts) ──────────
-export { parseExecutionEvidence, parseCriterionRevisions, parseWorkerResults, extractSelfEvaluation, buildSelfEvaluation, } from "./self-eval.js";
-function makeEngineMetrics() {
+import { CanonicalEventWriter } from "./canonical-event-writer.js";
+import { parseRoundReport, } from "./round-report.js";
+function makeRuntimeMetrics() {
     return {
         vaultWriteErrors: 0,
         sessionStart: Date.now(),
     };
 }
 // ═══════════════════════════════════════════════════════════════════════════
-// LoopForgeEngine
+// RuntimeServices
 // ═══════════════════════════════════════════════════════════════════════════
-export class LoopForgeEngine {
+export class RuntimeServices {
     state = null;
     backend = null;
     metrics = null;
+    eventWriter = null;
     lastTask = null;
-    constructor(storeOrBackend) {
-        if (storeOrBackend) {
-            this.backend = "readSession" in storeOrBackend
-                ? new LoopStoreBackend(storeOrBackend)
-                : storeOrBackend;
-        }
+    constructor(store) {
+        if (store)
+            this.backend = store;
     }
     resolveBackend() {
         if (this.backend === null) {
-            this.backend = new LoopStoreBackend(new FileLoopStore(getPolicy().backend.root_dir));
+            this.backend = new FileLoopStore(getPolicy().backend.root_dir);
         }
         return this.backend;
     }
@@ -46,10 +44,13 @@ export class LoopForgeEngine {
     getBackend() {
         return this.resolveBackend();
     }
-    /** Expose engine health counters for observability (MCP status, logging). */
+    writer() {
+        return this.eventWriter ??= new CanonicalEventWriter(this.resolveBackend());
+    }
+    /** Expose runtime health counters for observability (MCP status, logging). */
     getMetrics() {
         if (this.metrics === null) {
-            this.metrics = makeEngineMetrics();
+            this.metrics = makeRuntimeMetrics();
         }
         return this.metrics;
     }
@@ -58,62 +59,58 @@ export class LoopForgeEngine {
             this.state = makeSessionState(request.task_id || makeTaskId(request.task));
         }
         if (this.metrics === null) {
-            this.metrics = makeEngineMetrics();
+            this.metrics = makeRuntimeMetrics();
         }
     }
     // ═══════════════════════════════════════════════════════════════════════
-    // Feedback persistence
+    // Canonical round-event persistence
     // ═══════════════════════════════════════════════════════════════════════
-    persistFeedbackToVault(signal) {
+    persistRoundEvent(signal) {
         if (this.metrics === null) {
-            this.metrics = makeEngineMetrics();
+            this.metrics = makeRuntimeMetrics();
+        }
+        // Round events are committed synchronously by the canonical writer.
+        const entry = this.buildRoundEventEntry(signal);
+        if (!entry) {
+            throw new Error("Cannot persist a round event without a valid canonical RoundReport");
         }
-        // v2.6: write directly — the buffer was always flushed immediately
-        // (autoFeedback calls persistFeedbackToVault then immediately flushFeedbackBuffer).
-        const entry = this.buildFeedbackEntry(signal);
-        if (!entry)
-            return;
         try {
-            this.resolveBackend().appendEntry(entry);
+            this.writer().append(entry);
         }
-        catch {
+        catch (error) {
             if (this.metrics)
                 this.metrics.vaultWriteErrors++;
-            logEvent("vault_write_error", { error: "feedback_persist" });
+            logEvent("vault_write_error", { error: "round_event_persist" });
+            logEvent("persist_failure", { operation: "round_event" });
+            policyMetrics.recordVaultWriteError("round_event_persist");
+            throw new Error(`Round event persistence failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    buildFeedbackEntry(signal) {
+    buildRoundEventEntry(signal) {
         try {
+            const canonicalReport = parseRoundReport(signal.round_report);
+            if (!canonicalReport)
+                return null;
             return {
                 id: randomUUID(),
-                task_id: signal.task_id ?? "feedback",
-                version_tag: "v1",
+                task_id: signal.task_id ?? "round-event",
+                format: "loopforge.event",
                 is_active: true,
                 timestamp: new Date().toISOString().replace(/\.\d+Z$/, ""),
-                user_intent: String(signal.task_type ?? "").slice(0, 200),
-                success: signal.success ?? false,
-                execution_feedback: JSON.stringify({
-                    success: signal.success ?? false,
-                    status: signal.success ? "success" : "partial",
-                    constraint_compliance: {
-                        all_hard_constraints_met: !Array.isArray(signal.violations) || signal.violations.length === 0,
-                        violations: signal.violations ?? [],
-                    },
-                    output_summary: signal.task_type ?? "",
-                    improvement_notes: signal.manual_fixes ?? "",
-                }),
-                task_type: signal.task_type ?? "",
-                tags: signal.skill_used ? [signal.skill_used] : [],
-                skill_used: signal.skill_used ?? "",
+                user_intent: `round event ${String(signal.round ?? "")}`.trim(),
+                task_type: "round_event",
+                success: signal.success === true,
                 loop_id: signal.loop_id,
                 loop_lineage: signal.loop_lineage ?? {},
+                round_report: canonicalReport,
             };
         }
-        catch {
+        catch (error) {
             if (this.metrics)
                 this.metrics.vaultWriteErrors++;
-            logEvent("vault_write_error", { error: "feedback_entry_build" });
-            return null;
+            logEvent("vault_write_error", { error: "round_event_build" });
+            logEvent("persist_failure", { operation: "round_event_build" });
+            throw new Error(`Round event construction failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     // ═══════════════════════════════════════════════════════════════════════
@@ -121,7 +118,7 @@ export class LoopForgeEngine {
     // ═══════════════════════════════════════════════════════════════════════
     persistLoopLineage(response, request) {
         if (this.metrics === null)
-            this.metrics = makeEngineMetrics();
+            this.metrics = makeRuntimeMetrics();
         const loopObjDict = response.loop_objective
             ? response.loop_objective
             : null;
@@ -133,18 +130,11 @@ export class LoopForgeEngine {
             recompile_level: response.recompile_level,
             constraints_active: response.constraints_active,
             task: request.task,
-            success: true,
         };
-        let lastOutputSummary = "";
-        let lastViolations = [];
-        if (request.last_round_result) {
-            lastOutputSummary = request.last_round_result.output_summary || "";
-            lastViolations = request.last_round_result.constraint_violations || [];
-        }
         const entry = {
             id: randomUUID(),
             task_id: `loop:${response.loop_id}:r${response.round}`,
-            version_tag: "v1",
+            format: "loopforge.event",
             is_active: true,
             timestamp: new Date().toISOString().replace(/\.\d+Z$/, ""),
             user_intent: `loop_compile round ${response.round} — ${response.goal_id}`,
@@ -153,20 +143,21 @@ export class LoopForgeEngine {
             loop_lineage: structuredLineage,
             loop_objective: loopObjDict,
             task: request.task,
-            output_summary: lastOutputSummary,
-            constraint_violations: lastViolations,
             tags: [response.loop_id, response.recompile_level, response.goal_id],
         };
         // 1. JSON vault write (primary)
         let vaultOk = false;
         try {
-            this.resolveBackend().appendEntry(entry);
+            this.writer().append(entry);
             vaultOk = true;
         }
-        catch {
+        catch (error) {
             if (this.metrics)
                 this.metrics.vaultWriteErrors++;
             logEvent("vault_write_error", { error: "persist_lineage_json" });
+            logEvent("persist_failure", { operation: "lineage" });
+            policyMetrics.recordVaultWriteError("lineage_persist");
+            throw new Error(`Loop lineage persistence failed: ${error instanceof Error ? error.message : String(error)}`);
         }
         return vaultOk;
     }
@@ -180,14 +171,14 @@ export class LoopForgeEngine {
         if (!entries.length)
             return;
         const taskId = `loop:${loopId}:r${round}:delegations`;
-        const existing = this.resolveBackend().queryEntries({ prefix: taskId })
+        const existing = this.resolveBackend().queryLoopEvents(loopId)
             .some((candidate) => candidate.task_id === taskId);
         if (existing)
             return;
         const entry = {
             id: randomUUID(),
             task_id: taskId,
-            version_tag: "v1",
+            format: "loopforge.event",
             is_active: true,
             timestamp: new Date().toISOString().replace(/\.\d+Z$/, ""),
             user_intent: `Delegation journal — round ${round}`,
@@ -207,12 +198,15 @@ export class LoopForgeEngine {
             },
         };
         try {
-            this.resolveBackend().appendEntry(entry);
+            this.writer().append(entry);
         }
-        catch {
+        catch (error) {
             if (this.metrics)
                 this.metrics.vaultWriteErrors++;
             logEvent("vault_write_error", { error: "record_delegation" });
+            logEvent("persist_failure", { operation: "delegation" });
+            policyMetrics.recordVaultWriteError("delegation_persist");
+            throw new Error(`Failed to persist delegation journal for ${loopId} round ${round}`, { cause: error instanceof Error ? error : undefined });
         }
     }
     // ═══════════════════════════════════════════════════════════════════════
@@ -220,35 +214,55 @@ export class LoopForgeEngine {
     // ═══════════════════════════════════════════════════════════════════════
     hydrateLoopContext(loopId) {
         const prefix = `loop:${loopId}:r`;
-        const results = this.resolveBackend().queryEntries({ prefix });
-        // Merge feedback success flags into lineage entries
-        const fbEntries = this.resolveBackend().queryEntries({
-            prefix,
-            feedbackOnly: true,
-        });
-        const fbSuccess = new Map();
-        for (const fe of fbEntries) {
-            const tid = String(fe.task_id ?? "");
-            const parts = tid.split(":r");
-            if (parts.length >= 2) {
-                const roundStr = parts[1].split(":")[0];
-                const fbRound = parseInt(roundStr, 10);
-                if (!Number.isNaN(fbRound) && fe.success !== undefined) {
-                    fbSuccess.set(fbRound, fe.success);
+        // Hydration builds an ephemeral event projection. Clone entries
+        // before merging round events so a read can never mutate the Vault backend.
+        const loopEntries = this.resolveBackend().queryLoopEvents(loopId);
+        const results = [
+            ...loopEntries.filter((entry) => String(entry.task_id ?? "").startsWith(prefix)),
+            // Gate decisions are loop facts too; include them so the compiler can
+            // rebuild the active gate after a user decision across restarts.
+            ...loopEntries.filter((entry) => String(entry.task_id ?? "").startsWith(`loop:${loopId}:gate`)),
+        ].map((entry) => ({
+            ...entry,
+            loop_lineage: entry.loop_lineage ? { ...entry.loop_lineage } : undefined,
+        }));
+        // Merge round-event success flags into lineage entries
+        const roundEvents = loopEntries.filter((entry) => String(entry.task_id ?? "").startsWith(prefix) &&
+            String(entry.task_id ?? "").endsWith(":event"));
+        const eventSuccess = new Map();
+        const eventByRound = new Map();
+        for (const event of roundEvents) {
+            const tid = String(event.task_id ?? "");
+            // task_id is `loop:<loopId>:r<round>:event`. loopId may itself contain
+            // ":r" (validateLoopId permits colons), so a naive split(":r") would
+            // misparse. Greedy (.+) backtracks to the LAST `:r<digits>` segment,
+            // which is always the real round number.
+            const match = tid.match(/^loop:(.+):r(\d+)(?::.+)?$/);
+            if (match) {
+                const eventRound = parseInt(match[2], 10);
+                if (!Number.isNaN(eventRound) && event.success !== undefined) {
+                    eventSuccess.set(eventRound, event.success);
+                    eventByRound.set(eventRound, event);
                 }
             }
         }
         for (const entry of results) {
-            const lineage = (entry.loop_lineage ?? entry.lineage ?? {});
+            const lineage = (entry.loop_lineage ?? {});
             const rnd = lineage.round;
-            if (rnd && fbSuccess.has(rnd)) {
-                lineage.success = fbSuccess.get(rnd);
-                entry.success = fbSuccess.get(rnd);
+            if (rnd && eventSuccess.has(rnd)) {
+                lineage.success = eventSuccess.get(rnd);
+                entry.success = eventSuccess.get(rnd);
+                const event = eventByRound.get(rnd);
+                if (event?.round_report) {
+                    const report = parseRoundReport(event.round_report);
+                    if (report)
+                        entry.round_report = report;
+                }
             }
         }
         const finalResults = results;
         for (const entry of finalResults) {
-            const lineage = (entry.loop_lineage ?? entry.lineage ?? {});
+            const lineage = (entry.loop_lineage ?? {});
             if (!entry.output_summary) {
                 entry.output_summary = lineage.output_summary ?? "";
             }
@@ -262,94 +276,28 @@ export class LoopForgeEngine {
         return { results: finalResults, global_entries: [] };
     }
     // ═══════════════════════════════════════════════════════════════════════
-    // Feedback (public)
-    // ═══════════════════════════════════════════════════════════════════════
-    invokeFeedback(request, _hydrateResults) {
-        this.ensureInit(request);
-        this.lastTask = request.task;
-        const fb = request.feedback;
-        if (!fb) {
-            return {
-                status: AgentStatus.ERROR,
-                response: {
-                    status: AgentStatus.ERROR,
-                    prompt: null,
-                    error: "Feedback mode requires a feedback payload.",
-                },
-            };
-        }
-        const success = fb.success;
-        const violations = fb.constraint_violations ?? [];
-        const fixes = fb.manual_fixes_needed ?? "";
-        // Loop-aware task_id for feedback→lineage backfill
-        const loopId = request.loop_id;
-        const loopRound = request.round;
-        let taskId;
-        if (loopId && loopRound !== undefined) {
-            taskId = `loop:${loopId}:r${loopRound}:feedback`;
-        }
-        else {
-            taskId = request.task_id ?? request.task.slice(0, 60);
-        }
-        const signal = {
-            task_id: taskId,
-            task_type: request.task.slice(0, 80),
-            success,
-            skill_used: request.skill_name ?? "",
-            violations,
-            manual_fixes: fixes,
-            loop_id: loopId,
-            round: loopRound,
-        };
-        this.persistFeedbackToVault(signal);
-        // Update state
-        this.state.call_count++;
-        this.state.success_trend.push(success);
-        if (this.state.success_trend.length > 20) {
-            this.state.success_trend = this.state.success_trend.slice(-20);
-        }
-        logEvent("round_complete", {
-            success,
-            loopId: loopId ?? "unknown",
-            round: loopRound ?? this.state.call_count,
-        });
-        return {
-            status: AgentStatus.OK,
-            response: {
-                status: AgentStatus.OK,
-                prompt: `## Feedback Recorded\n\nSuccess: ${success}\nSignals: 1`,
-                error: null,
-            },
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════
-    // Auto-Feedback (v1.1 — autonomous loop, no human in the loop)
+    // Canonical round-event commit
     // ═══════════════════════════════════════════════════════════════════════
-    /** Record self-evaluation from agent output without human intervention.
-     *  Converts SelfEvaluation → ExecutionFeedback → vault persistence.
+    /** Record a round report and persist the canonical event.
+     *  Compiler views remain ephemeral and are never written as facts.
      *  P0–P2: Also persists discovered_constraints, objective_refinement,
      *  and emerged_subtasks for the compiler to consume next round.
      *  Call this BEFORE invokeLoopCompile for the next round so that
      *  hydrateLoopContext picks up the latest success flags. */
-    autoFeedback(selfEval, loopId, round, task, roundTransaction) {
-        this.ensureInit({ task, mode: Mode.FEEDBACK, feedback: null, skill_name: null, task_id: null });
-        const fb = makeExecutionFeedback({
-            output: selfEval.output_summary,
-            success: selfEval.success,
-            constraint_violations: selfEval.constraint_violations,
-            manual_fixes_needed: "",
-        });
-        const taskId = `loop:${loopId}:r${round}:feedback`;
+    commitRoundReport(loopId, round, task, roundTransaction, roundReport) {
+        if (!roundReport)
+            throw new Error("commitRoundReport requires a canonical RoundReport");
+        this.ensureInit({ task, mode: Mode.LOOP_COMPILE, skill_name: null, task_id: null });
+        const taskId = `loop:${loopId}:r${round}:event`;
         const transactionId = typeof roundTransaction?.round_id === "string"
             ? roundTransaction.round_id
             : null;
         const transactionPersisted = () => {
             if (!transactionId)
                 return false;
-            return this.resolveBackend().queryEntries({
-                prefix: taskId,
-                feedbackOnly: true,
-            }).some((entry) => {
+            return this.resolveBackend().queryLoopEvents(loopId)
+                .filter((entry) => entry.task_id === taskId)
+                .some((entry) => {
                 if (entry.task_id !== taskId)
                     return false;
                 const lineage = entry.loop_lineage;
@@ -361,34 +309,14 @@ export class LoopForgeEngine {
             });
         };
         const alreadyCommitted = transactionPersisted();
-        // Multi-agent: Merge sub-agent discovered constraints into the main constraint flow
-        const subDiscovered = (selfEval.worker_results ?? [])
-            .flatMap((w) => w.discoveredConstraints ?? [])
-            .filter((c) => c.length > 0);
-        const mergedDiscovered = [
-            ...new Set([...(selfEval.discovered_constraints ?? []), ...subDiscovered]),
-        ];
         const signal = {
             task_id: taskId,
-            task_type: task.slice(0, 80),
-            success: fb.success,
-            skill_used: "",
-            violations: selfEval.constraint_violations,
-            manual_fixes: "",
+            task_type: "round_event",
+            success: roundReport.outcome === "success",
             loop_id: loopId,
             round,
-            // P0–P2: Evolution fields
-            discovered_constraints: mergedDiscovered,
-            objective_refinement: selfEval.objective_refinement ?? "",
-            emerged_subtasks: selfEval.emerged_subtasks ?? [],
-            // P4: Execution evidence
-            execution_evidence: selfEval.execution_evidence ?? null,
-            // P5: Self-correction
-            retracted_constraints: selfEval.retracted_constraints ?? [],
-            revised_success_criteria: selfEval.revised_success_criteria ?? [],
-            wrong_assumptions: selfEval.wrong_assumptions ?? [],
-            // Multi-agent: Worker delegation results
-            worker_results: selfEval.worker_results ?? [],
+            format: "loopforge.event",
+            round_report: roundReport,
             loop_lineage: roundTransaction
                 ? {
                     round,
@@ -398,43 +326,19 @@ export class LoopForgeEngine {
                 : {},
         };
         if (!alreadyCommitted) {
-            this.persistFeedbackToVault(signal);
+            this.persistRoundEvent(signal);
             if (transactionId && !transactionPersisted()) {
-                throw new Error(`Round feedback commit failed: ${transactionId}`);
+                throw new Error(`Round event commit failed: ${transactionId}`);
             }
         }
-        // Multi-agent: Auto-record delegation journal from worker_results
-        if (selfEval.worker_results && selfEval.worker_results.length > 0) {
-            const entries = selfEval.worker_results.map((w, i) => ({
-                index: i + 1,
-                agentId: w.agentId,
-                subAgentType: w.subAgentType,
-                subTask: w.subTask,
-                resultSummary: w.resultSummary,
-                success: w.success,
-                discoveredConstraints: w.discoveredConstraints ?? [],
-            }));
-            this.recordDelegation(loopId, round, entries);
-        }
-        // Replaying a committed transaction may repair derived delegation data,
-        // but must never apply the feedback to mutable engine state twice.
         if (alreadyCommitted)
-            return fb.success;
-        // Update state
-        this.state.call_count++;
-        this.state.success_trend.push(fb.success);
-        if (this.state.success_trend.length > 20) {
-            this.state.success_trend = this.state.success_trend.slice(-20);
-        }
-        // v2.5: Old binary-success circuit breaker removed — stalled loops
-        // are now detected by the enforcement gate (R4/R5) using
-        // progress_estimate gradients rather than success=true/false count.
+            return roundReport.outcome === "success";
         logEvent("round_complete", {
             loopId,
             round,
-            success: fb.success,
+            success: roundReport.outcome === "success",
         });
-        return fb.success;
+        return roundReport.outcome === "success";
     }
     // ═══════════════════════════════════════════════════════════════════════
     // Loop Compile (public, primary)
@@ -470,58 +374,29 @@ export class LoopForgeEngine {
             attempt: parsed.attempt,
             consecutive_rejections: parsed.consecutive_rejections,
             rejection_notice: parsed.rejection_notice,
+            loop_objective: parsed.loop_objective,
         });
-        // Convert last_round_result if present (object already validated by parser)
-        if (parsed.last_round_result) {
-            const rr = parsed.last_round_result;
-            // Parse P4 execution evidence (shared helper)
-            const executionEvidence = parseExecutionEvidence(rr.execution_evidence);
-            // Parse P5 revised_success_criteria (shared parser)
-            const revisedCriteria = parseCriterionRevisions(rr.revised_success_criteria);
-            lcr.last_round_result = makeLoopRoundResult({
-                round: rr.round ?? 0,
-                success: rr.success ?? false,
-                output_summary: rr.output_summary ?? "",
-                constraint_violations: rr.constraint_violations ?? [],
-                manual_fixes_needed: rr.manual_fixes_needed ?? "",
-                // P0–P2: Cognitive evolution fields
-                discovered_constraints: Array.isArray(rr.discovered_constraints)
-                    ? rr.discovered_constraints.filter((v) => typeof v === "string")
-                    : [],
-                objective_refinement: typeof rr.objective_refinement === "string"
-                    ? rr.objective_refinement
-                    : "",
-                emerged_subtasks: Array.isArray(rr.emerged_subtasks)
-                    ? rr.emerged_subtasks.filter((v) => typeof v === "string")
-                    : [],
-                // P4: Execution evidence
-                execution_evidence: executionEvidence,
-                // P5: Self-correction
-                retracted_constraints: Array.isArray(rr.retracted_constraints)
-                    ? rr.retracted_constraints.filter((v) => typeof v === "string")
-                    : [],
-                revised_success_criteria: revisedCriteria,
-                wrong_assumptions: Array.isArray(rr.wrong_assumptions)
-                    ? rr.wrong_assumptions.filter((v) => typeof v === "string")
-                    : [],
-                // v1.10: Checkpoint boundary
-                compression_checkpoint: typeof rr.compression_checkpoint === "boolean" ? rr.compression_checkpoint : false,
-                checkpoint_label: typeof rr.checkpoint_label === "string" ? rr.checkpoint_label : "",
-                // v2.2: Sub-goal lifecycle
-                completed_subtasks: Array.isArray(rr.completed_subtasks)
-                    ? rr.completed_subtasks.filter((v) => typeof v === "string")
-                    : [],
-                blocked_subtasks: Array.isArray(rr.blocked_subtasks)
-                    ? rr.blocked_subtasks.filter((v) => typeof v === "string")
-                    : [],
-                canceled_subtasks: Array.isArray(rr.canceled_subtasks)
-                    ? rr.canceled_subtasks.filter((v) => typeof v === "string")
-                    : [],
-                // Multi-agent: Worker delegation results (shared parser)
-                worker_results: parseWorkerResults(rr.worker_results),
-            });
+        // Convert only the canonical compiler projection.
+        if (parsed.last_round_view) {
+            const rr = parsed.last_round_view;
+            if (rr.evidence && typeof rr.evidence === "object" &&
+                typeof rr.summary === "string") {
+                lcr.last_round_view = rr;
+            }
+            else {
+                return {
+                    status: AgentStatus.ERROR,
+                    response: {
+                        status: AgentStatus.ERROR,
+                        prompt: null,
+                        error: "last_round_view must be a CompilerRoundProjection",
+                    },
+                };
+            }
         }
-        // Convert loop_objective if present (object already validated by parser)
+        // Convert loop_objective if present (object already validated by parser).
+        // Preserve the caller-supplied version and refinement_history so
+        // objective versioning (P1) survives the request round-trip.
         if (parsed.loop_objective) {
             const obj = parsed.loop_objective;
             lcr.loop_objective = makeLoopObjective({
@@ -530,6 +405,12 @@ export class LoopForgeEngine {
                 hard_constraints: obj.hard_constraints ?? [],
                 created_at_round: obj.created_at_round ?? 1,
                 loop_id: obj.loop_id ?? "",
+                ...(typeof obj.version === "number" ? { version: obj.version } : {}),
+                ...(Array.isArray(obj.refinement_history)
+                    ? {
+                        refinement_history: obj.refinement_history.filter((item) => typeof item === "string"),
+                    }
+                    : {}),
             });
         }
         // Hydrate vault context for cross-round memory
@@ -564,6 +445,7 @@ export class LoopForgeEngine {
                 error: null,
                 state_file_content: response.state_file_content,
                 prompt_artifact: response.prompt_artifact,
+                canonical_state: response.canonical_state,
                 warnings: response.warnings,
             },
         };
@@ -572,7 +454,7 @@ export class LoopForgeEngine {
 // ═══════════════════════════════════════════════════════════════════════════
 // Factory
 // ═══════════════════════════════════════════════════════════════════════════
-export function createEngine(store) {
-    return new LoopForgeEngine(store);
+export function createRuntimeServices(store) {
+    return new RuntimeServices(store);
 }
-//# sourceMappingURL=engine.js.map
+//# sourceMappingURL=runtime-services.js.map