loopforge 1.12.0 → 2.0.0

package/dist/round-coordinator.d.ts

@@ -0,0 +1,90 @@
+/** RoundCoordinator — Unified round-boundary state machine (v1.17).
+ *
+ * Encapsulates the shared round processing pipeline used by both
+ * LoopRuntime (runtime.ts) and SessionManager (mcp/session.ts):
+ *
+ *   verify → enforce → stop decision
+ *
+ * Before this module, runtime.ts and session.ts each maintained their
+ * own copy of the pipeline (~60 lines each). Drift between the two
+ * paths (e.g. git verification only wired into one side) was a known
+ * risk. The RoundCoordinator is the single source of truth.
+ *
+ * State transitions:
+ *   RoundStarted → EvidenceCaptured → EvaluationSubmitted
+ *   → VerificationCompleted → EnforcementDecided
+ *
+ * Persistence is owned by round-transaction.ts so reject paths remain
+ * side-effect free and accepted decisions can be replayed idempotently.
+ */
+import type { VaultBackend } from "./backends/interface.js";
+import type { ProviderSnapshot } from "./evidence-provider.js";
+import type { SelfEvaluation, StopReason, VerificationFlag } from "./protocol.js";
+/** Input to a single round processing step. */
+export interface RoundProcessInput {
+    loopId: string;
+    task: string;
+    currentRound: number;
+    maxRounds: number;
+    /** The agent's self-evaluation for this round. */
+    selfEval: SelfEvaluation;
+    /** Whether structured extraction succeeded (false = heuristic fallback). */
+    extractionSucceeded: boolean;
+    /** The previous round's validated SelfEvaluation (null for round 1). */
+    lastSelfEval?: SelfEvaluation;
+    /** How many consecutive rounds have been rejected by enforcement. */
+    consecutiveRejections: number;
+    /** v1.16: Files detected as changed by git diff. null if git unavailable. */
+    runtimeFilesChanged?: string[] | null;
+    /** v1.18: Evidence snapshots from configured providers. */
+    evidenceSnapshots?: ProviderSnapshot[];
+    /** Success values from already committed rounds. */
+    successTrajectory?: boolean[];
+}
+/** Result of processing a round through the coordinator. */
+export interface RoundProcessResult {
+    /** What the caller should do next. */
+    action: "continue" | "stop" | "reject" | "terminate";
+    /** Reason for stop (set when action is "stop" or "terminate"). */
+    stopReason?: StopReason;
+    /** Rejection prompt (set when action is "reject"). */
+    rejectionPrompt?: string;
+    /** Verification flags from this round (for injection into next prompt). */
+    verificationFlags: VerificationFlag[];
+    /** Enforcement action for observability. */
+    enforcementAction?: "accept" | "reject" | "terminate";
+    /** Enforcement reason (set when rejected or terminated). */
+    enforcementReason?: string;
+    /** Whether this round was successful (from selfEval.success). */
+    roundSuccess: boolean;
+    /** Whether the verification gate returned "contradicted". */
+    gateContradicted: boolean;
+    /** Updated consecutiveRejections count — caller must persist. */
+    newConsecutiveRejections: number;
+    /** Which enforcement check fired (set when action is "reject" or "terminate").
+     *  Used by callers to track per-rule rejection counters. */
+    rejectionCheck?: string;
+    /** The selfEval to store as lastSelfEval for the next round
+     *  (undefined when action is "reject" — caller should NOT update). */
+    newLastSelfEval?: SelfEvaluation;
+    /** Whether the caller should push roundSuccess onto the success trajectory.
+     *  false when gateContradicted or when action is "reject". */
+    shouldPushSuccessTrajectory: boolean;
+}
+export declare class RoundCoordinator {
+    private backend;
+    constructor(backend?: VaultBackend);
+    /** Process a single round's self-evaluation through the decision pipeline:
+     *  verify → enforce → stop decision.
+     *
+     *  This is the single entry point called by both LoopRuntime and
+     *  SessionManager. The caller is responsible for:
+     *  - Compiling the next prompt (if action is "continue")
+     *  - Managing heartbeat / signal handlers (runtime only)
+     *  - Memory injection (both paths, before calling processRound)
+     *  - Transactional feedback commit (accepted rounds only)
+     *  - State file I/O (both paths, after compiling)
+     */
+    processRound(input: RoundProcessInput): RoundProcessResult;
+}
+//# sourceMappingURL=round-coordinator.d.ts.map

package/dist/round-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-coordinator.d.ts","sourceRoot":"","sources":["../src/round-coordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAEV,cAAc,EACd,UAAU,EACV,gBAAgB,EAEjB,MAAM,eAAe,CAAC;AAQvB,+CAA+C;AAC/C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,QAAQ,EAAE,cAAc,CAAC;IACzB,4EAA4E;IAC5E,mBAAmB,EAAE,OAAO,CAAC;IAC7B,wEAAwE;IACxE,YAAY,CAAC,EAAE,cAAc,CAAC;IAC9B,qEAAqE;IACrE,qBAAqB,EAAE,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACtC,2DAA2D;IAC3D,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACvC,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,OAAO,EAAE,CAAC;CAC/B;AAED,4DAA4D;AAC5D,MAAM,WAAW,kBAAkB;IACjC,sCAAsC;IACtC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;IACrD,kEAAkE;IAClE,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,sDAAsD;IACtD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,4CAA4C;IAC5C,iBAAiB,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;IACtD,4DAA4D;IAC5D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,YAAY,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iEAAiE;IACjE,wBAAwB,EAAE,MAAM,CAAC;IACjC;gEAC4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;0EACsE;IACtE,eAAe,CAAC,EAAE,cAAc,CAAC;IACjC;kEAC8D;IAC9D,2BAA2B,EAAE,OAAO,CAAC;CACtC;AAID,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAA2B;gBAE9B,OAAO,CAAC,EAAE,YAAY;IAIlC;;;;;;;;;;OAUG;IACH,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB;CAkL3D"}

package/dist/round-coordinator.js

@@ -0,0 +1,186 @@
+/** RoundCoordinator — Unified round-boundary state machine (v1.17).
+ *
+ * Encapsulates the shared round processing pipeline used by both
+ * LoopRuntime (runtime.ts) and SessionManager (mcp/session.ts):
+ *
+ *   verify → enforce → stop decision
+ *
+ * Before this module, runtime.ts and session.ts each maintained their
+ * own copy of the pipeline (~60 lines each). Drift between the two
+ * paths (e.g. git verification only wired into one side) was a known
+ * risk. The RoundCoordinator is the single source of truth.
+ *
+ * State transitions:
+ *   RoundStarted → EvidenceCaptured → EvaluationSubmitted
+ *   → VerificationCompleted → EnforcementDecided
+ *
+ * Persistence is owned by round-transaction.ts so reject paths remain
+ * side-effect free and accepted decisions can be replayed idempotently.
+ */
+import { verifySelfEvaluation } from "./verification-gate.js";
+import { enforceRound, buildRejectionPrompt } from "./enforcement-gate.js";
+import { logEvent } from "./observability.js";
+import { getPolicy } from "./policy.js";
+// ── RoundCoordinator ───────────────────────────────────────────────────────
+export class RoundCoordinator {
+    backend;
+    constructor(backend) {
+        this.backend = backend;
+    }
+    /** Process a single round's self-evaluation through the decision pipeline:
+     *  verify → enforce → stop decision.
+     *
+     *  This is the single entry point called by both LoopRuntime and
+     *  SessionManager. The caller is responsible for:
+     *  - Compiling the next prompt (if action is "continue")
+     *  - Managing heartbeat / signal handlers (runtime only)
+     *  - Memory injection (both paths, before calling processRound)
+     *  - Transactional feedback commit (accepted rounds only)
+     *  - State file I/O (both paths, after compiling)
+     */
+    processRound(input) {
+        const { loopId, task, currentRound, maxRounds, selfEval, extractionSucceeded, lastSelfEval, consecutiveRejections, runtimeFilesChanged, evidenceSnapshots, } = input;
+        const roundSuccess = selfEval.success ?? false;
+        // ── 1. Query vault entries ──────────────────────────────────────────
+        const vaultEntries = this.backend
+            ? this.backend.queryEntries({ prefix: `loop:${loopId}:r` })
+            : [];
+        // ── 2. Verification gate ────────────────────────────────────────────
+        const verifyResult = verifySelfEvaluation(selfEval, currentRound, vaultEntries, lastSelfEval ?? null, runtimeFilesChanged ?? null, evidenceSnapshots ?? []);
+        const verificationFlags = verifyResult.flags;
+        const gateContradicted = verifyResult.verdict === "contradicted";
+        if (gateContradicted) {
+            logEvent("gate_contradicted", {
+                loopId,
+                round: currentRound,
+                flags: verificationFlags.map((f) => f.check),
+            });
+        }
+        // ── 3. Enforcement gate (structured extractions only) ───────────────
+        // Heuristic evaluations have no reliable execution_evidence —
+        // enforcement rules that depend on evidence are skipped.
+        if (extractionSucceeded) {
+            const enforceResult = enforceRound(selfEval, verifyResult, currentRound, vaultEntries, consecutiveRejections);
+            if (enforceResult.action === "reject") {
+                const newRejections = consecutiveRejections + 1;
+                const rejectionPrompt = buildRejectionPrompt(currentRound, task, enforceResult);
+                logEvent("enforcement_reject", {
+                    loopId,
+                    round: currentRound,
+                    reason: enforceResult.reason.slice(0, 120),
+                    check: enforceResult.check ?? "",
+                    consecutiveRejections: newRejections,
+                });
+                return {
+                    action: "reject",
+                    rejectionPrompt,
+                    verificationFlags,
+                    enforcementAction: "reject",
+                    enforcementReason: enforceResult.reason,
+                    rejectionCheck: enforceResult.check,
+                    roundSuccess,
+                    gateContradicted,
+                    newConsecutiveRejections: newRejections,
+                    // Don't update lastSelfEval on reject — the agent redoes the same round
+                    newLastSelfEval: undefined,
+                    shouldPushSuccessTrajectory: false,
+                };
+            }
+            if (enforceResult.action === "terminate") {
+                logEvent("session_end", {
+                    loopId,
+                    stopReason: "enforcement_terminated",
+                    round: currentRound,
+                });
+                return {
+                    action: "terminate",
+                    stopReason: "enforcement_terminated",
+                    verificationFlags,
+                    enforcementAction: "terminate",
+                    enforcementReason: enforceResult.reason,
+                    rejectionCheck: enforceResult.check,
+                    roundSuccess,
+                    gateContradicted,
+                    newConsecutiveRejections: 0,
+                    newLastSelfEval: selfEval,
+                    shouldPushSuccessTrajectory: false,
+                };
+            }
+            // Accept: reset rejection counter
+            // (consecutiveRejections reset to 0 — caller persists)
+        }
+        // ── 4. Auto-feedback (AFTER enforcement, only if accepted) ──────────
+        // ── 5. Stop condition checks ────────────────────────────────────────
+        // 5a. Extraction failed → stalled
+        if (!extractionSucceeded) {
+            return {
+                action: "stop",
+                stopReason: "stalled",
+                verificationFlags,
+                roundSuccess,
+                gateContradicted,
+                newConsecutiveRejections: 0,
+                newLastSelfEval: selfEval,
+                shouldPushSuccessTrajectory: !gateContradicted,
+            };
+        }
+        // 5b. Agent says stop
+        if (!selfEval.should_continue) {
+            const reason = roundSuccess ? "completed" : "failed";
+            return {
+                action: "stop",
+                stopReason: reason,
+                verificationFlags,
+                roundSuccess,
+                gateContradicted,
+                newConsecutiveRejections: 0,
+                newLastSelfEval: selfEval,
+                shouldPushSuccessTrajectory: !gateContradicted,
+            };
+        }
+        // 5c. Circuit breaker
+        const projectedTrajectory = [...(input.successTrajectory ?? [])];
+        if (!gateContradicted)
+            projectedTrajectory.push(roundSuccess);
+        const breakerSize = getPolicy().engine.max_circuit_breaker;
+        const circuitBroken = projectedTrajectory.length >= breakerSize &&
+            projectedTrajectory.slice(-breakerSize).every((value) => !value);
+        if (circuitBroken) {
+            return {
+                action: "stop",
+                stopReason: "circuit_breaker",
+                verificationFlags,
+                roundSuccess,
+                gateContradicted,
+                newConsecutiveRejections: 0,
+                newLastSelfEval: selfEval,
+                shouldPushSuccessTrajectory: !gateContradicted,
+            };
+        }
+        // 5d. Max rounds reached
+        if (currentRound >= maxRounds) {
+            return {
+                action: "stop",
+                stopReason: "max_rounds",
+                verificationFlags,
+                roundSuccess,
+                gateContradicted,
+                newConsecutiveRejections: 0,
+                newLastSelfEval: selfEval,
+                shouldPushSuccessTrajectory: !gateContradicted,
+            };
+        }
+        // ── 6. Continue — caller compiles next round ────────────────────────
+        return {
+            action: "continue",
+            verificationFlags,
+            enforcementAction: "accept",
+            roundSuccess,
+            gateContradicted,
+            newConsecutiveRejections: 0,
+            newLastSelfEval: selfEval,
+            shouldPushSuccessTrajectory: !gateContradicted,
+        };
+    }
+}
+//# sourceMappingURL=round-coordinator.js.map

package/dist/round-coordinator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-coordinator.js","sourceRoot":"","sources":["../src/round-coordinator.ts"],"names":[],"mappings":"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"}

package/dist/round-driver.d.ts

@@ -0,0 +1,53 @@
+/** Shared round lifecycle used by Runtime and MCP adapters.
+ *
+ * The driver owns compile -> state projection -> before evidence and
+ * after evidence -> transaction evaluation. Transport-specific concerns such
+ * as heartbeats, executor deadlines, MCP leases, and response formatting stay
+ * in their adapters.
+ */
+import type { VaultBackend } from "./backends/interface.js";
+import { LoopForgeEngine } from "./engine.js";
+import type { ProviderSnapshot } from "./evidence-provider.js";
+import type { LoopForgeRequest, PromptArtifact, SelfEvaluation } from "./protocol.js";
+import type { RoundTransactionOutcome, RoundTransactionSnapshot } from "./round-transaction.js";
+export interface PreparedRound {
+    prompt: string;
+    artifact?: PromptArtifact;
+    level: "l0" | "l1" | "l2";
+    evidenceBaseline: ProviderSnapshot[];
+    snapshot: RoundTransactionSnapshot;
+    stateFileContent?: string;
+}
+export interface CompleteRoundInput {
+    snapshot: RoundTransactionSnapshot;
+    loopId: string;
+    task: string;
+    maxRounds: number;
+    selfEval: SelfEvaluation;
+    extractionSucceeded: boolean;
+    lastSelfEval?: SelfEvaluation;
+    consecutiveRejections: number;
+    successTrajectory: boolean[];
+}
+export interface CompletedRound {
+    outcome: RoundTransactionOutcome;
+    actualEvidence: ProviderSnapshot[];
+}
+export declare class RoundDriver {
+    private readonly engine;
+    private readonly backend;
+    constructor(engine: LoopForgeEngine, backend?: VaultBackend);
+    prepare(request: LoopForgeRequest, loopId: string, round: number): Promise<PreparedRound | null>;
+    /** Synchronous fallback for legacy embedding APIs. Async evidence providers
+     * are deliberately skipped by EvidenceCollector.collect(). */
+    prepareSync(request: LoopForgeRequest, loopId: string, round: number): PreparedRound | null;
+    private compile;
+    /** Compile a fresh prompt for a zero-commit enforcement retry. The logical
+     * round ID and before-evidence snapshot remain stable; only attempt changes. */
+    prepareRetry(request: LoopForgeRequest, rejected: RoundTransactionSnapshot, rejectionNotice: string, consecutiveRejections: number): Promise<PreparedRound | null>;
+    private finishPrepare;
+    complete(input: CompleteRoundInput): Promise<CompletedRound>;
+    recover(snapshot: RoundTransactionSnapshot): RoundTransactionOutcome | null;
+    private collectEvidence;
+}
+//# sourceMappingURL=round-driver.d.ts.map

package/dist/round-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-driver.d.ts","sourceRoot":"","sources":["../src/round-driver.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,KAAK,EACV,gBAAgB,EAEhB,cAAc,EACd,cAAc,EACf,MAAM,eAAe,CAAC;AAMvB,OAAO,KAAK,EACV,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,KAAK,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC1B,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;IACrC,QAAQ,EAAE,wBAAwB,CAAC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,wBAAwB,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,cAAc,CAAC;IACzB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,cAAc,CAAC;IAC9B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iBAAiB,EAAE,OAAO,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,uBAAuB,CAAC;IACjC,cAAc,EAAE,gBAAgB,EAAE,CAAC;CACpC;AAED,qBAAa,WAAW;IAGV,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;gBAEV,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,YAAY;IAItE,OAAO,CACX,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAOhC;kEAC8D;IAC9D,WAAW,CACT,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,IAAI;IASvB,OAAO,CAAC,OAAO;IAgBf;oFACgF;IAC1E,YAAY,CAChB,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,wBAAwB,EAClC,eAAe,EAAE,MAAM,EACvB,qBAAqB,EAAE,MAAM,GAC5B,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAsBhC,OAAO,CAAC,aAAa;IAuBf,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;IAoBlE,OAAO,CAAC,QAAQ,EAAE,wBAAwB,GAAG,uBAAuB,GAAG,IAAI;IAO3E,OAAO,CAAC,eAAe;CAMxB"}

package/dist/round-driver.js

@@ -0,0 +1,101 @@
+/** Shared round lifecycle used by Runtime and MCP adapters.
+ *
+ * The driver owns compile -> state projection -> before evidence and
+ * after evidence -> transaction evaluation. Transport-specific concerns such
+ * as heartbeats, executor deadlines, MCP leases, and response formatting stay
+ * in their adapters.
+ */
+import { EvidenceCollector } from "./evidence-provider.js";
+import { getPolicy, writeStateFile } from "./policy.js";
+import { prepareRejectedAttempt, prepareRoundTransaction, RoundTransactionCoordinator, } from "./round-transaction.js";
+export class RoundDriver {
+    engine;
+    backend;
+    constructor(engine, backend) {
+        this.engine = engine;
+        this.backend = backend ?? engine.getBackend();
+    }
+    async prepare(request, loopId, round) {
+        const response = this.compile(request, loopId, true);
+        if (!response)
+            return null;
+        const evidenceBaseline = await this.collectEvidence(loopId, "before");
+        return this.finishPrepare(response, loopId, round, evidenceBaseline);
+    }
+    /** Synchronous fallback for legacy embedding APIs. Async evidence providers
+     * are deliberately skipped by EvidenceCollector.collect(). */
+    prepareSync(request, loopId, round) {
+        const response = this.compile(request, loopId, true);
+        if (!response)
+            return null;
+        const evidenceBaseline = EvidenceCollector.fromProviderNames(getPolicy().evidence.providers).collect({ loopId });
+        return this.finishPrepare(response, loopId, round, evidenceBaseline);
+    }
+    compile(request, loopId, persistLineage) {
+        const compiled = this.engine.invokeLoopCompile(request, undefined, { persistLineage });
+        const response = compiled.response;
+        if (!response?.prompt)
+            return null;
+        writeStateFile(loopId, response.state_file_content);
+        return response;
+    }
+    /** Compile a fresh prompt for a zero-commit enforcement retry. The logical
+     * round ID and before-evidence snapshot remain stable; only attempt changes. */
+    async prepareRetry(request, rejected, rejectionNotice, consecutiveRejections) {
+        const retryRequest = {
+            ...request,
+            round: rejected.round,
+            attempt: rejected.attempt + 1,
+            consecutive_rejections: consecutiveRejections,
+            rejection_notice: rejectionNotice,
+            force_level: consecutiveRejections >= 2 ? "l2" : "l0",
+        };
+        const response = this.compile(retryRequest, rejected.loopId, false);
+        if (!response?.prompt_artifact)
+            return null;
+        const snapshot = prepareRejectedAttempt(rejected, response.prompt_artifact);
+        return {
+            prompt: response.prompt,
+            artifact: response.prompt_artifact,
+            level: response.prompt_artifact.level,
+            evidenceBaseline: rejected.beforeEvidence,
+            snapshot,
+            stateFileContent: response.state_file_content,
+        };
+    }
+    finishPrepare(response, loopId, round, evidenceBaseline) {
+        const artifact = response.prompt_artifact;
+        const snapshot = prepareRoundTransaction(loopId, round, evidenceBaseline, artifact);
+        return {
+            prompt: response.prompt,
+            artifact,
+            level: artifact?.level ?? "l2",
+            evidenceBaseline,
+            snapshot,
+            stateFileContent: response.state_file_content,
+        };
+    }
+    async complete(input) {
+        const actualEvidence = await this.collectEvidence(input.loopId, "after");
+        const transaction = new RoundTransactionCoordinator(this.engine, this.backend);
+        const outcome = transaction.process({
+            snapshot: input.snapshot,
+            task: input.task,
+            maxRounds: input.maxRounds,
+            selfEval: input.selfEval,
+            extractionSucceeded: input.extractionSucceeded,
+            lastSelfEval: input.lastSelfEval,
+            consecutiveRejections: input.consecutiveRejections,
+            successTrajectory: input.successTrajectory,
+            actualEvidence,
+        });
+        return { outcome, actualEvidence };
+    }
+    recover(snapshot) {
+        return new RoundTransactionCoordinator(this.engine, this.backend).recover(snapshot);
+    }
+    collectEvidence(loopId, phase) {
+        return EvidenceCollector.fromPolicy().collectAsync({ loopId, phase });
+    }
+}
+//# sourceMappingURL=round-driver.js.map

package/dist/round-driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-driver.js","sourceRoot":"","sources":["../src/round-driver.ts"],"names":[],"mappings":"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"}

package/dist/round-transaction.d.ts

@@ -0,0 +1,70 @@
+/** Schema-versioned round transaction shared by Runtime and MCP.
+ *
+ * A logical round has one deterministic roundId. Rejected attempts keep the
+ * same identity and before snapshot; only accepted decisions are committed to
+ * feedback storage. The committed feedback embeds the decision so replay after
+ * a process crash is idempotent.
+ */
+import type { VaultBackend } from "./backends/interface.js";
+import { LoopForgeEngine } from "./engine.js";
+import type { ProviderSnapshot } from "./evidence-provider.js";
+import type { SelfEvaluation } from "./protocol.js";
+import type { PromptArtifact } from "./protocol.js";
+import { type RoundProcessResult } from "./round-coordinator.js";
+import type { RoundCommitStore } from "./storage.js";
+export declare const ROUND_TRANSACTION_SCHEMA_VERSION: 1;
+export type RoundTransactionPhase = "prepared" | "prompted" | "evaluated" | "rejected" | "committed" | "terminated";
+export interface RoundTransactionSnapshot {
+    schemaVersion: typeof ROUND_TRANSACTION_SCHEMA_VERSION;
+    roundId: string;
+    loopId: string;
+    round: number;
+    attempt: number;
+    phase: RoundTransactionPhase;
+    beforeEvidence: ProviderSnapshot[];
+    afterEvidence?: ProviderSnapshot[];
+    roundEvidence?: ProviderSnapshot[];
+    evaluation?: SelfEvaluation;
+    result?: RoundProcessResult;
+    createdAt: number;
+    updatedAt: number;
+    /** Exact prompt delivered for the current attempt. */
+    promptArtifact?: PromptArtifact;
+}
+export interface RoundTransactionInput {
+    snapshot: RoundTransactionSnapshot;
+    task: string;
+    maxRounds: number;
+    selfEval: SelfEvaluation;
+    extractionSucceeded: boolean;
+    lastSelfEval?: SelfEvaluation;
+    consecutiveRejections: number;
+    successTrajectory: boolean[];
+    actualEvidence: ProviderSnapshot[];
+}
+export interface RoundTransactionOutcome {
+    snapshot: RoundTransactionSnapshot;
+    result: RoundProcessResult;
+    /** true when a prior committed decision was replayed from the vault. */
+    replayed: boolean;
+}
+export declare function makeRoundId(loopId: string, round: number): string;
+export declare function prepareRoundTransaction(loopId: string, round: number, beforeEvidence: ProviderSnapshot[], promptArtifact?: PromptArtifact): RoundTransactionSnapshot;
+/** Attach the next prompt attempt to a rejected logical round without changing
+ * its identity or evidence baseline. Evaluation fields belong to the previous
+ * attempt and are cleared before the Agent receives the retry prompt. */
+export declare function prepareRejectedAttempt(rejected: RoundTransactionSnapshot, promptArtifact: PromptArtifact): RoundTransactionSnapshot;
+/** Parse a persisted snapshot without trusting arbitrary vault data. */
+export declare function parseRoundTransactionSnapshot(value: unknown): RoundTransactionSnapshot | null;
+export declare class RoundTransactionCoordinator {
+    private readonly engine;
+    private readonly backend;
+    private readonly commitStore;
+    constructor(engine: LoopForgeEngine, backend?: VaultBackend, commitStore?: RoundCommitStore);
+    process(input: RoundTransactionInput): RoundTransactionOutcome;
+    /** Recover an already committed decision without evaluating or writing. */
+    recover(snapshot: RoundTransactionSnapshot): RoundTransactionOutcome | null;
+    private readCommitted;
+    private outcomeFromEntry;
+}
+//# sourceMappingURL=round-transaction.d.ts.map

package/dist/round-transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-transaction.d.ts","sourceRoot":"","sources":["../src/round-transaction.ts"],"names":[],"mappings":"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"}