loopforge 1.12.0 → 2.0.0

package/dist/mcp/session.js

@@ -6,25 +6,30 @@
  */
 import { randomUUID } from "node:crypto";
 import { LoopForgeEngine, extractSelfEvaluation, heuristicSelfEvaluation } from "../engine.js";
-import { checkLoopHealth, tokenize, jaccard } from "../loop-compiler.js";
-import { getPolicy, resolveAllowedPhases } from "../policy.js";
-import { Mode, makeLoopCompileRequest, makeVaultConfig } from "../protocol.js";
+import { checkLoopHealth } from "../loop-compiler.js";
+import { getPolicy } from "../policy.js";
+import { Mode, makeLoopCompileRequest } from "../protocol.js";
 import { ReplayBackend } from "../replay.js";
-import { FSBackend } from "../backends/fs.js";
-import { verifySelfEvaluation } from "../verification-gate.js";
+import { FileLoopStore, LoopStoreBackend } from "../loop-store.js";
+import { EvidenceCollector } from "../evidence-provider.js";
+import { parseRoundTransactionSnapshot, prepareRoundTransaction, } from "../round-transaction.js";
+import { RoundDriver } from "../round-driver.js";
 import { logEvent } from "../observability.js";
+import { policyMetrics } from "../policy-metrics.js";
+import { SessionLeaseConflictError, VaultSessionStateStore, } from "../storage.js";
+import { createCognitiveCheckpoint } from "../interop.js";
 // ── Helpers ────────────────────────────────────────────────────────────────
 function buildLoopRequest(session, lastEval, _lastQuality, // deprecated — kept for backward compat
 verificationFlags) {
     const req = {
         task: session.task,
         mode: Mode.LOOP_COMPILE,
-        vault_config: makeVaultConfig(),
         feedback: null,
         skill_name: null,
         task_id: null,
         loop_id: session.loopId,
         round: session.currentRound,
+        max_rounds: session.maxRounds,
         verification_flags: verificationFlags ?? [],
     };
     if (lastEval) {
@@ -55,19 +60,12 @@ verificationFlags) {
             // v1.10: Checkpoint boundary
             compression_checkpoint: lastEval.compression_checkpoint ?? false,
             checkpoint_label: lastEval.checkpoint_label ?? "",
+            // v1.16: Agent's declared next action
+            next_action: lastEval.next_action,
         };
     }
     return req;
 }
-function parseLevel(rationale) {
-    if (!rationale)
-        return "l2";
-    if (rationale.includes("l0"))
-        return "l0";
-    if (rationale.includes("l1"))
-        return "l1";
-    return "l2";
-}
 function parseWarnings(prompt) {
     if (!prompt)
         return [];
@@ -85,76 +83,166 @@ function parseWarnings(prompt) {
 // ── SessionManager ─────────────────────────────────────────────────────────
 export class SessionManager {
     sessions = new Map();
+    /** Serializes state transitions for each session. */
+    sessionQueues = new Map();
     backend;
-    /** Optional provider for long-term memory context retrieval. */
-    memoryProvider;
-    /** Optional writer for persisting loop knowledge back to long-term memory. */
-    memoryWriter;
-    constructor(backend) {
-        this.backend = backend;
+    sessionStore;
+    ownerId = `${process.pid}:${randomUUID()}`;
+    leaseMs;
+    leaseRenewIntervalMs;
+    leaseTimer = null;
+    checkpointSinks = new Set();
+    /** Explicit context provider; never auto-discovered. */
+    contextProvider;
+    terminalSinks = new Set();
+    constructor(storeOrBackend, sessionStore) {
+        const resolvedBackend = storeOrBackend
+            ? "readSession" in storeOrBackend
+                ? new LoopStoreBackend(storeOrBackend)
+                : storeOrBackend
+            : new LoopStoreBackend(new FileLoopStore(getPolicy().backend.root_dir));
+        this.backend = resolvedBackend;
+        this.sessionStore = sessionStore ?? new VaultSessionStateStore(resolvedBackend);
+        const mcpPolicy = getPolicy().mcp;
+        this.leaseMs = Math.max(1, mcpPolicy.session_lease_ms);
+        this.leaseRenewIntervalMs = Math.max(1, Math.min(mcpPolicy.session_lease_renew_interval_ms, this.leaseMs));
+        if (this.sessionStore?.renewLease) {
+            this.leaseTimer = setInterval(() => this.renewOwnedLeases(), this.leaseRenewIntervalMs);
+            this.leaseTimer.unref?.();
+        }
+    }
+    /** Stable process-local owner token used for cross-process session leases. */
+    getOwnerId() {
+        return this.ownerId;
+    }
+    /** Subscribe an external checkpointer; sink failures are isolated. */
+    addCheckpointSink(sink) {
+        this.checkpointSinks.add(sink);
+        return () => this.checkpointSinks.delete(sink);
+    }
+    addTerminalSink(sink) {
+        this.terminalSinks.add(sink);
+        return () => this.terminalSinks.delete(sink);
+    }
+    /** Release owned sessions and stop lease maintenance. */
+    close() {
+        if (this.leaseTimer)
+            clearInterval(this.leaseTimer);
+        this.leaseTimer = null;
+        for (const session of this.sessions.values()) {
+            this.sessionStore?.releaseLease?.(session.loopId, this.ownerId);
+        }
+    }
+    findSessionEntry(loopId) {
+        return this.sessionStore?.load(loopId);
+    }
+    claimSessionEntry(loopId) {
+        if (this.sessionStore?.acquireLease) {
+            return this.sessionStore.acquireLease(loopId, this.ownerId, this.leaseMs);
+        }
+        return this.findSessionEntry(loopId);
+    }
+    renewSessionLease(loopId) {
+        if (!this.sessionStore?.renewLease)
+            return true;
+        try {
+            return this.sessionStore.renewLease(loopId, this.ownerId, this.leaseMs);
+        }
+        catch {
+            return false;
+        }
+    }
+    renewOwnedLeases() {
+        for (const session of this.sessions.values()) {
+            if (session.status === "running")
+                this.renewSessionLease(session.loopId);
+        }
+    }
+    leaseConflictResult(loopId, entry) {
+        const lineage = (entry?.loop_lineage ?? {});
+        return {
+            sessionId: "",
+            round: typeof lineage.current_round === "number" ? lineage.current_round : 0,
+            prompt: null,
+            stopReason: `session_owned_elsewhere:${loopId}`,
+        };
+    }
+    async withSessionQueue(sessionId, work) {
+        const previous = this.sessionQueues.get(sessionId) ?? Promise.resolve();
+        let release;
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const tail = previous.then(() => gate);
+        this.sessionQueues.set(sessionId, tail);
+        await previous;
+        try {
+            return await work();
+        }
+        finally {
+            release();
+            if (this.sessionQueues.get(sessionId) === tail) {
+                this.sessionQueues.delete(sessionId);
+            }
+        }
     }
     async create(input) {
         const sessionId = randomUUID();
         const loopId = input.loopId ?? randomUUID();
-        const engine = new LoopForgeEngine("skills", this.backend);
+        const engine = new LoopForgeEngine(this.backend);
         const maxRounds = input.maxRounds ?? getPolicy().runtime.max_rounds;
         // Populate extra fields for the first round
         const request = buildLoopRequest({
             sessionId, loopId, task: input.task, engine, currentRound: 1,
             maxRounds, successTrajectory: [], status: "running", createdAt: Date.now(),
-            injectionCount: 0, lastInjectionRound: 0, injectedContexts: [],
-            phase2Triggered: false, phase3Triggered: false,
+            consecutiveRejections: 0,
+            lastRejectionCheck: "",
+            evidenceBaseline: [],
         });
         request.domain = input.domain ?? "";
         request.plan_source = input.planSource ?? null;
         request.constraints_from_plan = input.constraints ?? [];
-        // v1.8: Phase 1 memory injection (Round 1) — only if allowed by tier
-        const miPolicy = getPolicy().memory_injection;
-        const allowedPhases = new Set(resolveAllowedPhases(maxRounds, miPolicy.round_tiers));
-        if (miPolicy.enabled && this.memoryProvider && allowedPhases.has(1)) {
+        // Explicit context is requested by the MCP embedding; no auto-discovery.
+        if (this.contextProvider) {
             try {
                 const ctx = {
                     loopId,
                     round: 1,
                     task: input.task,
                     domain: input.domain ?? "",
-                    phase: 1,
-                    progressEstimate: 0,
-                    accumulatedContext: {
-                        recurringIssues: [],
-                        failedPatterns: [],
-                        keyLessons: [],
-                        remainingCriteria: [],
-                    },
                 };
-                const rawContext = await this.memoryProvider(ctx);
+                const rawContext = await this.contextProvider(ctx);
                 if (rawContext?.trim()) {
-                    request.external_context = rawContext.trim().slice(0, miPolicy.max_context_length);
-                    logEvent("memory_injected", {
-                        loopId, round: 1, phase: 1, injectionCount: 1,
+                    request.external_context = rawContext.trim();
+                    logEvent("external_context_loaded", {
+                        loopId, round: 1,
                         contextLength: request.external_context.length,
                     });
                 }
             }
             catch {
-                // memoryProvider failed — degrade gracefully
-                logEvent("memory_provider_error", { loopId, round: 1 });
+                // Provider failures are isolated from session creation.
+                logEvent("context_provider_error", { loopId, round: 1 });
             }
         }
-        const result = engine.invokeLoopCompile(request);
-        const injectedCtx = request.external_context;
+        const prepared = await new RoundDriver(engine, this.backend).prepare(request, loopId, 1);
+        const initialPrompt = prepared?.prompt ?? null;
+        const initialLevel = prepared?.level ?? "l2";
+        const evidenceBaseline = prepared?.evidenceBaseline ?? [];
         const session = {
             sessionId, loopId, task: input.task, engine,
             currentRound: 1, maxRounds, successTrajectory: [],
             status: "running", createdAt: Date.now(),
-            // v1.7: Memory integration state
-            injectionCount: injectedCtx ? 1 : 0,
-            lastInjectionRound: injectedCtx ? 1 : 0,
-            injectedContexts: injectedCtx ? [injectedCtx] : [],
-            phase2Triggered: false,
-            phase3Triggered: false,
+            // v1.13: Enforcement gate state
+            consecutiveRejections: 0,
+            lastRejectionCheck: "",
+            evidenceBaseline,
+            roundSnapshot: prepared?.snapshot ?? prepareRoundTransaction(loopId, 1, evidenceBaseline),
+            currentPrompt: initialPrompt,
+            currentLevel: initialLevel,
         };
         this.sessions.set(sessionId, session);
+        policyMetrics.recordStrategy(loopId, initialLevel);
         // Persist to vault for cross-process recovery
         this.save(session);
         logEvent("session_start", {
@@ -166,97 +254,382 @@ export class SessionManager {
         return {
             sessionId,
             round: 1,
-            prompt: result.response?.prompt ?? null,
-            technique: result.response?.analysis?.technique ?? "zero-shot",
-            level: parseLevel(result.response?.analysis?.rationale),
+            roundId: session.roundSnapshot?.roundId,
+            prompt: initialPrompt,
+            level: initialLevel,
             roundSuccess: false,
             quality: 0,
-            warnings: parseWarnings(result.response?.prompt ?? null),
+            warnings: parseWarnings(initialPrompt),
         };
     }
     get(sessionId) {
         return this.sessions.get(sessionId);
     }
+    getLeaseStatus(loopId) {
+        const entry = this.findSessionEntry(loopId);
+        if (!entry)
+            return null;
+        const lineage = (entry.loop_lineage ?? {});
+        const owner = typeof lineage.lease_owner === "string"
+            ? lineage.lease_owner
+            : "";
+        const ownerPid = owner.match(/^(\d+):/)?.[1];
+        return {
+            ownedByThisProcess: owner === this.ownerId,
+            ownerPid: ownerPid ? Number(ownerPid) : null,
+            expiresAt: typeof lineage.lease_expires_at === "number"
+                ? new Date(lineage.lease_expires_at).toISOString()
+                : null,
+            epoch: typeof lineage.lease_epoch === "number"
+                ? lineage.lease_epoch
+                : 0,
+        };
+    }
     delete(sessionId) {
         const session = this.sessions.get(sessionId);
         if (!session)
             return false;
         session.status = "stopped";
-        void this.doWriteback(session, "stopped");
+        this.save(session); // Persist stopped status to vault so autoResumeAll won't resurrect
+        void this.notifyTerminal(session, "cancelled");
         this.sessions.delete(sessionId);
         logEvent("session_end", {
             sessionId,
             loopId: session.loopId,
-            stopReason: "stopped",
+            stopReason: "cancelled",
             roundsCompleted: session.currentRound,
         });
         return true;
     }
+    /** v1.18: Pause a running session. The session state is persisted to
+     *  vault so it survives process restarts. Returns the session status.
+     *  Paused sessions cannot be advanced — they must be resumed first. */
+    pause(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return { sessionId, round: 0, status: "not_found" };
+        if (session.status !== "running") {
+            return { sessionId, round: session.currentRound, status: session.status };
+        }
+        session.status = "paused";
+        this.save(session);
+        logEvent("session_paused", {
+            sessionId,
+            loopId: session.loopId,
+            round: session.currentRound,
+        });
+        return { sessionId, round: session.currentRound, status: "paused" };
+    }
+    restoredPromptResult(session) {
+        if (!session.currentPrompt)
+            return null;
+        return {
+            sessionId: session.sessionId,
+            round: session.currentRound,
+            roundId: session.roundSnapshot?.roundId,
+            prompt: session.currentPrompt,
+            level: session.currentLevel ?? "l2",
+            quality: 0,
+            roundSuccess: undefined,
+            warnings: parseWarnings(session.currentPrompt),
+        };
+    }
+    /** Reconcile the crash window where feedback committed but session_state
+     *  still points at the old prompt. Returns null when no commit is pending. */
+    reconcileCommittedRound(session) {
+        if (!session.roundSnapshot)
+            return null;
+        const recovered = new RoundDriver(session.engine, this.backend).recover(session.roundSnapshot);
+        if (!recovered)
+            return null;
+        const pr = recovered.result;
+        session.roundSnapshot = recovered.snapshot;
+        // Replay the committed counter — but with per-rule tracking.
+        if (pr.action === "reject" && pr.rejectionCheck) {
+            session.consecutiveRejections =
+                pr.rejectionCheck === session.lastRejectionCheck
+                    ? pr.newConsecutiveRejections
+                    : 1;
+            session.lastRejectionCheck = pr.rejectionCheck;
+        }
+        else {
+            session.consecutiveRejections = pr.newConsecutiveRejections;
+            if (pr.action !== "reject")
+                session.lastRejectionCheck = "";
+        }
+        if (pr.newLastSelfEval)
+            session.lastSelfEval = pr.newLastSelfEval;
+        if (pr.shouldPushSuccessTrajectory &&
+            session.successTrajectory.length < session.currentRound) {
+            session.successTrajectory.push(pr.roundSuccess);
+        }
+        session.currentPrompt = null;
+        if (pr.action === "stop" || pr.action === "terminate") {
+            const reason = pr.action === "terminate"
+                ? "enforcement_terminated"
+                : pr.stopReason ?? "stalled";
+            session.status = reason === "stalled" ? "stalled" : "stopped";
+            this.save(session);
+            void this.notifyTerminal(session, reason);
+            return {
+                sessionId: session.sessionId,
+                round: session.currentRound,
+                roundId: recovered.snapshot.roundId,
+                prompt: null,
+                stopReason: reason,
+                roundSuccess: pr.roundSuccess,
+                quality: pr.roundSuccess ? 5 : 1,
+            };
+        }
+        if (pr.action !== "continue")
+            return null;
+        session.currentRound++;
+        const request = buildLoopRequest(session, pr.newLastSelfEval, pr.roundSuccess ? 5 : 1, pr.verificationFlags);
+        const prepared = new RoundDriver(session.engine, this.backend).prepareSync(request, session.loopId, session.currentRound);
+        if (!prepared) {
+            session.status = "stalled";
+            this.save(session);
+            return {
+                sessionId: session.sessionId,
+                round: session.currentRound,
+                prompt: null,
+                stopReason: "stalled",
+            };
+        }
+        const prompt = prepared.prompt;
+        session.evidenceBaseline = prepared.evidenceBaseline;
+        session.roundSnapshot = prepared.snapshot;
+        session.currentPrompt = prompt;
+        session.currentLevel = prepared.level;
+        policyMetrics.recordStrategy(session.loopId, session.currentLevel);
+        this.save(session);
+        return {
+            sessionId: session.sessionId,
+            round: session.currentRound,
+            roundId: session.roundSnapshot.roundId,
+            prompt,
+            level: session.currentLevel,
+            roundSuccess: pr.roundSuccess,
+            quality: pr.roundSuccess ? 5 : 1,
+            warnings: parseWarnings(prompt),
+        };
+    }
+    /** v1.18: Resume a paused session. Reconstructs from vault state and
+     *  compiles the next prompt. Returns null if no paused session exists
+     *  for this loopId. */
+    async unpause(loopId) {
+        const persistedEntry = this.findSessionEntry(loopId);
+        if (!persistedEntry)
+            return null;
+        const lineage = (persistedEntry.loop_lineage ?? {});
+        const status = lineage.status ?? "running";
+        if (status !== "paused")
+            return null;
+        const sessionEntry = this.claimSessionEntry(loopId);
+        if (!sessionEntry)
+            return this.leaseConflictResult(loopId, persistedEntry);
+        const session = this.reconstructSession(sessionEntry, true);
+        if (!session)
+            return null;
+        // Set to running so advance() works
+        session.status = "running";
+        this.sessions.set(session.sessionId, session);
+        // Replace the sync-fallback evidence baseline with async evidence
+        // so resumed sessions don't silently drop async provider data.
+        try {
+            const asyncEvidence = await EvidenceCollector.fromPolicy().collectAsync({
+                loopId: session.loopId,
+                phase: "before",
+            });
+            if (asyncEvidence.length > 0) {
+                session.evidenceBaseline = asyncEvidence;
+                if (!session.roundSnapshot?.beforeEvidence?.length) {
+                    session.roundSnapshot = prepareRoundTransaction(session.loopId, session.currentRound, asyncEvidence);
+                }
+            }
+        }
+        catch {
+            // Async evidence is best-effort; fall back to sync baseline.
+        }
+        const reconciled = this.reconcileCommittedRound(session);
+        if (reconciled)
+            return reconciled;
+        const restored = this.restoredPromptResult(session);
+        if (restored) {
+            this.save(session);
+            return restored;
+        }
+        // Compile the next prompt from the current round state
+        const lcr = makeLoopCompileRequest({
+            loop_id: session.loopId,
+            round: session.currentRound,
+            goal_id: "",
+            task: session.task,
+            domain: undefined,
+            plan_source: null,
+            constraints_from_plan: [],
+            health_check_interval: 1,
+        });
+        const compileRequest = {
+            task: session.task,
+            mode: Mode.LOOP_COMPILE,
+            feedback: null,
+            skill_name: null,
+            task_id: null,
+            loop_id: lcr.loop_id,
+            round: lcr.round,
+            goal_id: lcr.goal_id,
+            domain: lcr.domain ?? "",
+            plan_source: lcr.plan_source ?? null,
+            constraints_from_plan: lcr.constraints_from_plan ?? [],
+            health_check_interval: lcr.health_check_interval,
+            max_rounds: session.maxRounds,
+        };
+        const prepared = await new RoundDriver(session.engine, this.backend).prepare(compileRequest, session.loopId, session.currentRound);
+        if (!prepared) {
+            session.status = "stopped";
+            this.save(session);
+            void this.notifyTerminal(session, "stalled");
+            return { sessionId: session.sessionId, round: session.currentRound, prompt: null, stopReason: "stalled" };
+        }
+        const prompt = prepared.prompt;
+        const level = prepared.level;
+        session.evidenceBaseline = prepared.evidenceBaseline;
+        session.roundSnapshot = prepared.snapshot;
+        session.currentPrompt = prompt;
+        session.currentLevel = level;
+        policyMetrics.recordStrategy(session.loopId, level);
+        this.save(session);
+        return {
+            sessionId: session.sessionId,
+            round: session.currentRound,
+            roundId: session.roundSnapshot.roundId,
+            prompt,
+            level,
+            quality: 0,
+            roundSuccess: undefined,
+            warnings: [],
+        };
+    }
     /** Persist session state to vault for cross-process recovery.
-     *  Uses upsert: removes any previous session_state entry for this loop,
-     *  then appends a new one with current state.
-     *  Entire read→filter→write→append is wrapped in a file lock to prevent
-     *  lost updates from concurrent processes. */
+     *  The filtered vault and replacement entry are written once under the
+     *  backend lock, so recovery never observes the old two-write gap. */
     save(session) {
-        if (!this.backend)
+        if (!this.sessionStore)
             return;
-        const doSave = () => {
-            // Upsert: remove old session_state entries for this loop
-            const vault = this.backend.readVault();
-            const entries = vault.entries || [];
-            vault.entries = entries.filter((e) => !(e.task_type === "session_state" && e.loop_id === session.loopId));
-            this.backend.writeVault(vault);
-            // Append fresh session state
-            this.backend.appendEntry({
-                task_id: `loop:${session.loopId}:session`,
-                task_type: "session_state",
-                timestamp: new Date().toISOString(),
-                loop_id: session.loopId,
-                task: session.task,
-                loop_lineage: {
-                    session_id: session.sessionId,
-                    current_round: session.currentRound,
-                    max_rounds: session.maxRounds,
-                    success_trajectory: session.successTrajectory,
-                    status: session.status,
-                    created_at: session.createdAt,
-                    // v1.7: Memory integration state for cross-process recovery
-                    injection_count: session.injectionCount,
-                    last_injection_round: session.lastInjectionRound,
-                    phase2_triggered: session.phase2Triggered,
-                    phase3_triggered: session.phase3Triggered,
-                },
-            });
+        const leaseActive = session.status === "running";
+        const sessionEntry = {
+            task_id: `loop:${session.loopId}:session`,
+            task_type: "session_state",
+            timestamp: new Date().toISOString(),
+            loop_id: session.loopId,
+            task: session.task,
+            loop_lineage: {
+                session_id: session.sessionId,
+                current_round: session.currentRound,
+                max_rounds: session.maxRounds,
+                success_trajectory: session.successTrajectory,
+                status: session.status,
+                created_at: session.createdAt,
+                // v1.13: Enforcement gate state
+                consecutive_rejections: session.consecutiveRejections,
+                last_rejection_check: session.lastRejectionCheck,
+                // v1.19: durable round transaction state
+                round_snapshot: session.roundSnapshot ?? null,
+                last_self_eval: session.lastSelfEval ?? null,
+                current_prompt: session.currentPrompt ?? null,
+                current_level: session.currentLevel ?? "",
+                // v1.20: cross-process single-owner lease
+                lease_owner: leaseActive ? this.ownerId : "",
+                lease_expires_at: leaseActive ? Date.now() + this.leaseMs : 0,
+            },
         };
-        // Use FSBackend's file lock if available (only FSBackend implements withLock)
-        if ("withLock" in this.backend &&
-            typeof this.backend.withLock === "function") {
-            this.backend.withLock(doSave);
+        this.sessionStore.save(sessionEntry, {
+            expectedLeaseOwner: this.ownerId,
+        });
+        if (this.checkpointSinks.size > 0) {
+            const checkpoint = createCognitiveCheckpoint(session, sessionEntry.timestamp);
+            for (const sink of this.checkpointSinks) {
+                try {
+                    const pending = sink.save(checkpoint);
+                    if (pending && typeof pending.then === "function") {
+                        void pending.catch(() => undefined);
+                    }
+                }
+                catch {
+                    // External adapters must not affect session durability.
+                }
+            }
         }
-        else {
-            doSave();
+    }
+    /** Reconstruct a McpSession from a vault session_state entry.
+     *  Returns null if the entry is not "running" status.
+     *  Shared by resume() and autoResumeAll(). */
+    reconstructSession(entry, allowPaused = false) {
+        const lineage = (entry.loop_lineage ?? {});
+        const status = lineage.status ?? "running";
+        if (status !== "running" && !(allowPaused && status === "paused")) {
+            return null;
         }
+        const loopId = entry.loop_id;
+        const currentRound = lineage.current_round ?? 1;
+        const successTrajectory = lineage.success_trajectory ?? lineage.quality_trajectory ?? [];
+        const task = entry.task ?? "";
+        const maxRounds = lineage.max_rounds ?? getPolicy().runtime.max_rounds;
+        const roundSnapshot = parseRoundTransactionSnapshot(lineage.round_snapshot);
+        const fallbackEvidence = EvidenceCollector.fromProviderNames(getPolicy().evidence.providers).collect();
+        const persistedEval = lineage.last_self_eval;
+        const lastSelfEval = persistedEval !== null &&
+            typeof persistedEval === "object" &&
+            !Array.isArray(persistedEval) &&
+            typeof persistedEval.success === "boolean" &&
+            typeof persistedEval.output_summary === "string"
+            ? persistedEval
+            : undefined;
+        const engine = new LoopForgeEngine(this.backend);
+        return {
+            sessionId: typeof lineage.session_id === "string" && lineage.session_id
+                ? lineage.session_id
+                : randomUUID(),
+            loopId, task, engine,
+            currentRound, maxRounds, successTrajectory,
+            status: status,
+            createdAt: lineage.created_at ?? Date.now(),
+            consecutiveRejections: lineage.consecutive_rejections ?? 0,
+            lastRejectionCheck: typeof lineage.last_rejection_check === "string"
+                ? lineage.last_rejection_check
+                : "",
+            evidenceBaseline: roundSnapshot?.beforeEvidence ?? fallbackEvidence,
+            roundSnapshot: roundSnapshot ?? prepareRoundTransaction(loopId, currentRound, fallbackEvidence),
+            lastSelfEval,
+            currentPrompt: typeof lineage.current_prompt === "string"
+                ? lineage.current_prompt
+                : null,
+            currentLevel: typeof lineage.current_level === "string"
+                ? lineage.current_level
+                : undefined,
+        };
     }
     /** Resume a loop from vault state.
      *  Reconstructs the session and compiles the prompt for the next round.
      *  Returns null if no session_state entry exists for this loopId. */
     resume(loopId) {
-        if (!this.backend)
+        const persistedEntry = this.findSessionEntry(loopId);
+        if (!persistedEntry)
             return null;
-        const entries = this.backend.queryEntries({
-            prefix: `loop:${loopId}:session`,
-        });
-        const sessionEntry = entries.find((e) => e.task_type === "session_state");
+        const persistedLineage = (persistedEntry.loop_lineage ?? {});
+        const persistedStatus = persistedLineage.status ?? "running";
+        const sessionEntry = persistedStatus === "running"
+            ? this.claimSessionEntry(loopId)
+            : persistedEntry;
         if (!sessionEntry)
-            return null;
-        const lineage = (sessionEntry.loop_lineage ?? {});
-        const status = lineage.status ?? "running";
-        const currentRound = lineage.current_round ?? 1;
-        const successTrajectory = lineage.success_trajectory ?? lineage.quality_trajectory ?? [];
-        const task = sessionEntry.task ?? "";
-        const maxRounds = lineage.max_rounds ?? getPolicy().runtime.max_rounds;
-        // If the loop was already stopped or stalled, return immediately
-        if (status !== "running") {
+            return this.leaseConflictResult(loopId, persistedEntry);
+        const session = this.reconstructSession(sessionEntry);
+        if (!session) {
+            // was not "running" — return stopped/stalled status
+            const lineage = (sessionEntry.loop_lineage ?? {});
+            const currentRound = lineage.current_round ?? 1;
+            const status = lineage.status ?? "stopped";
             return {
                 sessionId: "",
                 round: currentRound,
@@ -264,41 +637,70 @@ export class SessionManager {
                 stopReason: status,
             };
         }
-        // Reconstruct session with a fresh engine
-        const engine = new LoopForgeEngine("skills", this.backend);
-        const sessionId = randomUUID();
-        const session = {
-            sessionId,
-            loopId,
-            task,
-            engine,
-            currentRound,
-            maxRounds,
-            successTrajectory,
-            status: "running",
-            createdAt: lineage.created_at ?? Date.now(),
-            // v1.7: Memory integration state restored from vault
-            injectionCount: lineage.injection_count ?? 0,
-            lastInjectionRound: lineage.last_injection_round ?? 0,
-            injectedContexts: [],
-            phase2Triggered: lineage.phase2_triggered ?? false,
-            phase3Triggered: lineage.phase3_triggered ?? false,
-        };
-        this.sessions.set(sessionId, session);
-        // Compile the next round's prompt from vault lineage
+        this.sessions.set(session.sessionId, session);
+        const reconciled = this.reconcileCommittedRound(session);
+        if (reconciled)
+            return reconciled;
+        const restored = this.restoredPromptResult(session);
+        if (restored)
+            return restored;
+        // Legacy session without a stored prompt: compile once, then persist it.
         const request = buildLoopRequest(session);
-        const result = engine.invokeLoopCompile(request);
+        const prepared = new RoundDriver(session.engine, this.backend).prepareSync(request, session.loopId, session.currentRound);
+        const prompt = prepared?.prompt ?? null;
+        session.evidenceBaseline = prepared?.evidenceBaseline ?? [];
+        session.roundSnapshot = prepared?.snapshot ?? prepareRoundTransaction(session.loopId, session.currentRound, []);
+        session.currentPrompt = prompt;
+        session.currentLevel = prepared?.level ?? "l2";
+        policyMetrics.recordStrategy(session.loopId, session.currentLevel);
+        this.save(session);
         return {
-            sessionId,
-            round: currentRound,
-            prompt: result.response?.prompt ?? null,
-            technique: result.response?.analysis?.technique ?? "zero-shot",
-            level: parseLevel(result.response?.analysis?.rationale),
+            sessionId: session.sessionId,
+            round: session.currentRound,
+            roundId: session.roundSnapshot.roundId,
+            prompt,
+            level: session.currentLevel,
             roundSuccess: false,
             quality: 0,
-            warnings: parseWarnings(result.response?.prompt ?? null),
+            warnings: parseWarnings(prompt),
         };
     }
+    /** Auto-resume all "running" sessions from vault on server startup.
+     *  Scans vault for session_state entries, reconstructs each as an in-memory
+     *  McpSession (without compiling — the next loopforge_next will do that).
+     *  Returns the number of sessions resumed. */
+    autoResumeAll() {
+        if (!this.sessionStore)
+            return 0;
+        const entries = this.sessionStore.list();
+        // Build set of already-active loopIds
+        const activeLoopIds = new Set();
+        for (const s of this.sessions.values()) {
+            activeLoopIds.add(s.loopId);
+        }
+        let count = 0;
+        for (const entry of entries) {
+            if (entry.task_type !== "session_state")
+                continue;
+            const lid = entry.loop_id;
+            if (!lid || activeLoopIds.has(lid))
+                continue;
+            const lineage = (entry.loop_lineage ?? {});
+            const status = lineage.status ?? "running";
+            if (status !== "running" && status !== "paused")
+                continue;
+            const claimedEntry = this.claimSessionEntry(lid);
+            if (!claimedEntry)
+                continue;
+            const session = this.reconstructSession(claimedEntry, true);
+            if (session) {
+                this.sessions.set(session.sessionId, session);
+                activeLoopIds.add(lid);
+                count++;
+            }
+        }
+        return count;
+    }
     list() {
         const seen = new Set();
         const result = [];
@@ -312,10 +714,9 @@ export class SessionManager {
                 status: s.status,
             });
         }
-        // Merge vault-persisted sessions not already in memory
-        if (this.backend) {
-            const vault = this.backend.readVault();
-            const entries = vault.entries ?? [];
+        // Merge persisted sessions not already in memory
+        if (this.sessionStore) {
+            const entries = this.sessionStore.list();
             for (const e of entries) {
                 if (e.task_type !== "session_state")
                     continue;
@@ -350,11 +751,8 @@ export class SessionManager {
             }
         }
         // Fall back to vault for task
-        if (!task && this.backend) {
-            const entries = this.backend.queryEntries({
-                prefix: `loop:${loopId}:session`,
-            });
-            const sessionEntry = entries.find((e) => e.task_type === "session_state");
+        if (!task) {
+            const sessionEntry = this.findSessionEntry(loopId);
             if (sessionEntry) {
                 task = sessionEntry.task ?? "";
             }
@@ -362,7 +760,7 @@ export class SessionManager {
         if (!task)
             return null;
         // Hydrate vault context
-        const engine = new LoopForgeEngine("skills", this.backend);
+        const engine = new LoopForgeEngine(this.backend);
         const vaultContext = engine.hydrateLoopContext(loopId);
         // Build a minimal request for health check
         const request = makeLoopCompileRequest({
@@ -379,6 +777,7 @@ export class SessionManager {
             drift_detected: health.drift_detected,
             strategy_stability: health.strategy_stability,
             task_continuity: health.task_continuity,
+            policy_metrics: policyMetrics.snapshot(loopId),
         };
     }
     /** Core cycle: extract self-eval → record feedback → check stop → compile next.
@@ -386,6 +785,24 @@ export class SessionManager {
      *    When provided (MCP path with evaluation parameter), skips regex extraction.
      *    When undefined (runtime/CLI path), falls back to regex extraction from output. */
     async advance(sessionId, output, preExtractedEval) {
+        return this.withSessionQueue(sessionId, async () => {
+            const session = this.sessions.get(sessionId);
+            if (session?.status === "running" &&
+                !this.renewSessionLease(session.loopId)) {
+                return this.leaseConflictResult(session.loopId, this.findSessionEntry(session.loopId));
+            }
+            try {
+                return await this.advanceUnlocked(sessionId, output, preExtractedEval);
+            }
+            catch (error) {
+                if (error instanceof SessionLeaseConflictError) {
+                    return this.leaseConflictResult(error.loopId, this.findSessionEntry(error.loopId));
+                }
+                throw error;
+            }
+        });
+    }
+    async advanceUnlocked(sessionId, output, preExtractedEval) {
         const session = this.sessions.get(sessionId);
         if (!session)
             return { sessionId, round: 0, prompt: null, stopReason: "session_not_found" };
@@ -408,211 +825,196 @@ export class SessionManager {
         if (!selfEval) {
             session.status = "stalled";
             this.save(session);
-            void this.doWriteback(session, "stalled");
+            void this.notifyTerminal(session, "stalled");
             logEvent("session_end", { sessionId, loopId: session.loopId, stopReason: "stalled", round: session.currentRound });
             return { sessionId, round: session.currentRound, prompt: null, stopReason: "stalled", roundSuccess: false, quality: 0 };
         }
-        // 1.5. Verification gate — cross-round consistency check (v1.6)
-        let verificationFlags = [];
-        let gateVerdict = "trusted";
-        {
-            const vaultEntries = this.backend
-                ? this.backend.queryEntries({ prefix: `loop:${session.loopId}:r` })
-                : [];
-            const verifyResult = verifySelfEvaluation(selfEval, session.currentRound, vaultEntries, session.lastSelfEval ?? null);
-            verificationFlags = verifyResult.flags;
-            gateVerdict = verifyResult.verdict;
-        }
-        // 2. Record feedback (flushes immediately so next compile sees success flags)
-        const roundSuccess = session.engine.autoFeedback(selfEval, session.loopId, session.currentRound, session.task);
-        // Contradicted verdict: skip success trend
-        if (gateVerdict !== "contradicted") {
-            session.successTrajectory.push(roundSuccess);
-        }
-        // Note: feedback vault entry is always persisted via autoFeedback above.
-        // Only the in-memory trend is skipped — the raw data stays for audit.
-        // Store selfEval for next round's verification gate.
-        // NOTE: lastSelfEval is intentionally NOT persisted to vault (save()).
-        // A resumed session starts with lastSelfEval=undefined, which means the
-        // first round after resumption runs with degraded verification (most
-        // checks skip without prevSelfEval). The gate recovers on the next round.
-        session.lastSelfEval = selfEval;
-        // Build deprecated quality alias for backward compat
-        const deprecatedQuality = roundSuccess ? 5 : 1;
-        // 3. Stop conditions (extraction-first order — see memory)
-        if (extractionFailed) {
-            session.status = "stalled";
-            this.save(session);
-            void this.doWriteback(session, "stalled");
-            logEvent("session_end", { sessionId, loopId: session.loopId, stopReason: "stalled", round: session.currentRound });
-            return { sessionId, round: session.currentRound, prompt: null, stopReason: "stalled", roundSuccess, quality: deprecatedQuality };
+        // 1.5. Unified transaction: before → evaluate → verify → commit/reject.
+        const snapshot = session.roundSnapshot ?? prepareRoundTransaction(session.loopId, session.currentRound, session.evidenceBaseline ?? []);
+        const completed = await new RoundDriver(session.engine, this.backend).complete({
+            snapshot,
+            loopId: session.loopId,
+            task: session.task,
+            maxRounds: session.maxRounds,
+            selfEval,
+            extractionSucceeded: !extractionFailed,
+            lastSelfEval: session.lastSelfEval,
+            consecutiveRejections: session.consecutiveRejections,
+            successTrajectory: session.successTrajectory,
+        });
+        const outcome = completed.outcome;
+        const actualSnapshots = completed.actualEvidence;
+        session.roundSnapshot = outcome.snapshot;
+        const pr = outcome.result;
+        policyMetrics.recordStrategyOutcome(session.loopId, session.currentLevel, pr, outcome.replayed);
+        const verificationFlags = pr.verificationFlags;
+        // Track per-rule rejections: only same-check rejections
+        // accumulate. A different rejection reason resets the counter.
+        if (pr.action === "reject" && pr.rejectionCheck) {
+            session.consecutiveRejections =
+                pr.rejectionCheck === session.lastRejectionCheck
+                    ? pr.newConsecutiveRejections
+                    : 1;
+            session.lastRejectionCheck = pr.rejectionCheck;
         }
-        if (!selfEval.should_continue) {
-            session.status = "stopped";
+        else {
+            session.consecutiveRejections = pr.newConsecutiveRejections;
+            if (pr.action !== "reject")
+                session.lastRejectionCheck = "";
+        }
+        if (pr.newLastSelfEval)
+            session.lastSelfEval = pr.newLastSelfEval;
+        if (pr.shouldPushSuccessTrajectory) {
+            session.successTrajectory.push(pr.roundSuccess);
+        }
+        // Handle enforcement actions
+        if (pr.action === "reject") {
+            const retryRequest = buildLoopRequest(session, undefined, undefined, verificationFlags);
+            const preparedRetry = await new RoundDriver(session.engine, this.backend).prepareRetry(retryRequest, session.roundSnapshot, pr.rejectionPrompt ?? "", session.consecutiveRejections);
+            if (!preparedRetry) {
+                session.status = "stalled";
+                session.currentPrompt = null;
+                this.save(session);
+                return {
+                    sessionId,
+                    round: session.currentRound,
+                    roundId: session.roundSnapshot.roundId,
+                    prompt: null,
+                    stopReason: "stalled",
+                };
+            }
+            session.roundSnapshot = preparedRetry.snapshot;
+            session.currentPrompt = preparedRetry.prompt;
+            session.currentLevel = preparedRetry.level;
             this.save(session);
-            void this.doWriteback(session, "task_complete");
-            logEvent("session_end", { sessionId, loopId: session.loopId, stopReason: "task_complete", round: session.currentRound });
-            return { sessionId, round: session.currentRound, prompt: null, stopReason: "task_complete", roundSuccess, quality: deprecatedQuality };
+            return {
+                sessionId,
+                round: session.currentRound,
+                roundId: session.roundSnapshot.roundId,
+                prompt: preparedRetry.prompt,
+                level: preparedRetry.level,
+                enforcementAction: "reject",
+                enforcementReason: pr.enforcementReason,
+            };
         }
-        if (session.engine.shouldBreak()) {
+        // Accepted rounds advance the before-snapshot. Rejected rounds retain the
+        // original baseline so their retry is still a zero-commit transaction.
+        session.evidenceBaseline = actualSnapshots;
+        if (pr.action === "terminate") {
             session.status = "stopped";
+            session.currentPrompt = null;
             this.save(session);
-            void this.doWriteback(session, "circuit_breaker");
-            logEvent("session_end", { sessionId, loopId: session.loopId, stopReason: "circuit_breaker", round: session.currentRound });
-            return { sessionId, round: session.currentRound, prompt: null, stopReason: "circuit_breaker", roundSuccess, quality: deprecatedQuality };
+            void this.notifyTerminal(session, "enforcement_terminated");
+            logEvent("session_end", {
+                sessionId, loopId: session.loopId,
+                stopReason: "enforcement_terminated", round: session.currentRound,
+            });
+            return {
+                sessionId,
+                round: session.currentRound,
+                roundId: session.roundSnapshot.roundId,
+                prompt: null,
+                stopReason: "enforcement_terminated",
+                enforcementAction: "terminate",
+                enforcementReason: pr.enforcementReason,
+            };
         }
-        if (session.currentRound >= session.maxRounds) {
-            session.status = "stopped";
+        if (pr.action === "stop") {
+            const reason = pr.stopReason ?? "stalled";
+            session.status = reason === "stalled" ? "stalled" : "stopped";
+            session.currentPrompt = null;
             this.save(session);
-            void this.doWriteback(session, "max_rounds");
-            logEvent("session_end", { sessionId, loopId: session.loopId, stopReason: "max_rounds", round: session.currentRound });
-            return { sessionId, round: session.currentRound, prompt: null, stopReason: "max_rounds", roundSuccess, quality: deprecatedQuality };
+            void this.notifyTerminal(session, reason);
+            logEvent("session_end", { sessionId, loopId: session.loopId, stopReason: reason, round: session.currentRound });
+            return { sessionId, round: session.currentRound, roundId: session.roundSnapshot.roundId, prompt: null, stopReason: reason, roundSuccess: pr.roundSuccess, quality: pr.roundSuccess ? 5 : 1 };
         }
-        // 4. Compile next round
+        const roundSuccess = pr.roundSuccess;
+        // Feedback + decision metadata were committed by the transaction layer.
+        // Build deprecated quality alias for backward compat
+        const deprecatedQuality = roundSuccess ? 5 : 1;
+        // 4. Compile next round after the accepted commit.
         session.currentRound++;
+        session.currentPrompt = null;
         // v1.8: Memory injection for phases 2/3 — tier-aware
         let externalCtx = "";
-        const miPolicy = getPolicy().memory_injection;
-        if (miPolicy.enabled && this.memoryProvider) {
-            const allowedPhases = new Set(resolveAllowedPhases(session.maxRounds, miPolicy.round_tiers));
-            if (session.injectionCount < allowedPhases.size &&
-                session.currentRound - session.lastInjectionRound >= miPolicy.min_rounds_between_injections) {
-                const progress = selfEval.execution_evidence?.progress_estimate;
-                const hasProgress = typeof progress === "number" && progress >= 0;
-                let phase = null;
-                if (allowedPhases.has(2) &&
-                    !session.phase2Triggered &&
-                    hasProgress &&
-                    progress >= miPolicy.phase_thresholds.phase2.threshold) {
-                    phase = 2;
-                    session.phase2Triggered = true;
-                }
-                else if (allowedPhases.has(3) &&
-                    !session.phase3Triggered &&
-                    hasProgress &&
-                    progress >= miPolicy.phase_thresholds.phase3.threshold) {
-                    phase = 3;
-                    session.phase3Triggered = true;
-                }
-                if (phase !== null) {
-                    try {
-                        const accCtx = {
-                            recurringIssues: selfEval.constraint_violations ?? [],
-                            failedPatterns: [],
-                            keyLessons: selfEval.emerged_subtasks ?? [],
-                            remainingCriteria: selfEval.execution_evidence?.success_criteria_remaining ?? [],
-                        };
-                        const ctx = {
-                            loopId: session.loopId,
-                            round: session.currentRound,
-                            task: session.task,
-                            domain: "",
-                            phase,
-                            progressEstimate: hasProgress ? progress : -1,
-                            accumulatedContext: accCtx,
-                        };
-                        const rawContext = await this.memoryProvider(ctx);
-                        if (rawContext?.trim()) {
-                            // Dedup
-                            const newTokens = tokenize(rawContext);
-                            let isDuplicate = false;
-                            for (const old of session.injectedContexts) {
-                                if (jaccard(newTokens, tokenize(old)) > miPolicy.dedup_threshold) {
-                                    isDuplicate = true;
-                                    break;
-                                }
-                            }
-                            if (!isDuplicate) {
-                                externalCtx = rawContext.trim().slice(0, miPolicy.max_context_length);
-                                session.injectionCount++;
-                                session.lastInjectionRound = session.currentRound;
-                                session.injectedContexts.push(externalCtx);
-                                logEvent("memory_injected", {
-                                    loopId: session.loopId, round: session.currentRound,
-                                    phase, injectionCount: session.injectionCount,
-                                    contextLength: externalCtx.length,
-                                });
-                            }
-                        }
-                    }
-                    catch {
-                        logEvent("memory_provider_error", {
-                            loopId: session.loopId, round: session.currentRound,
-                        });
-                    }
-                }
+        if (this.contextProvider) {
+            try {
+                externalCtx = (await this.contextProvider({
+                    loopId: session.loopId,
+                    round: session.currentRound,
+                    task: session.task,
+                    domain: "",
+                    lastEvaluation: selfEval,
+                })).trim();
+            }
+            catch {
+                logEvent("context_provider_error", {
+                    loopId: session.loopId,
+                    round: session.currentRound,
+                });
             }
         }
+        // pause()/delete() are intentionally synchronous for API compatibility.
+        // They may run while the memory provider above is awaited.  Treat the
+        // session map + status as a commit fence so an in-flight advance cannot
+        // compile/save another round after a terminal lifecycle transition.
+        if (this.sessions.get(sessionId) !== session || session.status !== "running") {
+            return {
+                sessionId,
+                round: session.currentRound,
+                prompt: null,
+                stopReason: session.status,
+                roundSuccess,
+                quality: deprecatedQuality,
+            };
+        }
         const request = buildLoopRequest(session, selfEval, deprecatedQuality, verificationFlags);
         if (externalCtx) {
             request.external_context = externalCtx;
         }
-        const result = session.engine.invokeLoopCompile(request);
+        const prepared = await new RoundDriver(session.engine, this.backend).prepare(request, session.loopId, session.currentRound);
+        const nextPrompt = prepared?.prompt ?? null;
+        const nextLevel = prepared?.level ?? "l2";
+        const nextBaseline = prepared?.evidenceBaseline ?? actualSnapshots;
+        session.evidenceBaseline = nextBaseline;
+        session.roundSnapshot = prepared?.snapshot ?? prepareRoundTransaction(session.loopId, session.currentRound, nextBaseline);
+        session.currentPrompt = nextPrompt;
+        session.currentLevel = nextLevel;
+        policyMetrics.recordStrategy(session.loopId, nextLevel);
         this.save(session);
         return {
             sessionId,
             round: session.currentRound,
-            prompt: result.response?.prompt ?? null,
-            technique: result.response?.analysis?.technique ?? "zero-shot",
-            level: parseLevel(result.response?.analysis?.rationale),
+            roundId: session.roundSnapshot.roundId,
+            prompt: nextPrompt,
+            level: nextLevel,
             roundSuccess,
             quality: deprecatedQuality,
-            warnings: parseWarnings(result.response?.prompt ?? null),
+            warnings: parseWarnings(nextPrompt),
         };
     }
     /** Write back loop knowledge to long-term memory.
-     *  Called when a loop terminates for any reason. */
-    async doWriteback(session, stopReason) {
-        if (!this.memoryWriter)
-            return;
-        const wp = getPolicy().memory_writeback;
-        if (!wp.enabled)
-            return;
-        if (wp.write_on_outcomes.length > 0 && !wp.write_on_outcomes.includes(stopReason))
+     *  Uses shared base builder from policy.ts. Called when a loop terminates. */
+    async notifyTerminal(session, stopReason) {
+        if (this.terminalSinks.size === 0)
             return;
-        if (session.currentRound < 1)
-            return;
-        const outcome = ["completed", "circuit_breaker", "stalled", "max_rounds", "stopped"].find((o) => stopReason === o) ?? "stopped";
-        try {
-            const payload = {
-                loopId: session.loopId,
-                task: session.task,
-                outcome,
-                roundsCompleted: session.currentRound,
-                projectEntry: {
-                    title: `${session.task.slice(0, 80)} — ${outcome}`,
-                    objective: session.task.slice(0, 200),
-                    keyOutcome: outcome === "completed"
-                        ? `Completed successfully in ${session.currentRound} rounds.`
-                        : `Terminated with reason '${stopReason}' after ${session.currentRound} rounds.`,
-                    keyDiscoveries: [],
-                    date: new Date().toISOString().split("T")[0],
-                },
-                feedbackEntries: [],
-                referenceEntry: {
-                    description: `LoopForge vault data for "${session.task.slice(0, 80)}"`,
-                    vaultLocation: `.promptcraft/prompt_vault.json → loop:${session.loopId}:*`,
-                },
-            };
-            await this.memoryWriter(payload);
-            logEvent("memory_writeback", {
-                loopId: session.loopId, stopReason,
-                feedbackCount: payload.feedbackEntries.length,
-            });
-        }
-        catch {
-            logEvent("memory_writeback_error", {
-                loopId: session.loopId, stopReason,
-            });
-        }
+        const event = {
+            loopId: session.loopId,
+            task: session.task,
+            success: stopReason === "completed",
+            stopReason: stopReason,
+            roundsCompleted: session.currentRound,
+            successTrajectory: [...session.successTrajectory],
+            lastEvaluation: session.lastSelfEval,
+        };
+        await Promise.allSettled([...this.terminalSinks].map((sink) => Promise.resolve(sink(event))));
     }
     /** Replay timeline for a session — creates ReplayBackend from the stored backend. */
     replayTimeline(sessionId) {
         const session = this.sessions.get(sessionId);
         if (!session)
             return null;
-        const vaultBackend = this.backend ?? new FSBackend();
-        const replay = new ReplayBackend(vaultBackend);
+        const replay = new ReplayBackend(this.backend);
         return replay.timeline(session.loopId);
     }
 }