@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/propose-review-control-dSNPjFUH.js

@@ -1,1458 +0,0 @@
-import { t as TraceEmitter } from "./emitter-CPBAhxum.js";
-import { s as validateRunRecord } from "./run-record-BmSPWXJR.js";
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname } from "node:path";
-//#region src/action-policy.ts
-function evaluateActionPolicy(action, policy = {}, options = {}) {
-	const reasons = [];
-	let blocked = false;
-	let requiresApproval = Boolean(action.requiresApproval);
-	if (policy.allowedTypes?.length && !policy.allowedTypes.includes(action.type)) {
-		blocked = true;
-		reasons.push(`action type "${action.type}" is not allowed`);
-	}
-	if (policy.blockedTypes?.includes(action.type)) {
-		blocked = true;
-		reasons.push(`action type "${action.type}" is blocked`);
-	}
-	if (policy.alwaysRequireApprovalTypes?.includes(action.type)) {
-		requiresApproval = true;
-		reasons.push(`action type "${action.type}" requires approval`);
-	}
-	if (policy.requireApprovalForExternalSideEffects && action.externalSideEffect) {
-		requiresApproval = true;
-		reasons.push("external side effect requires approval");
-	}
-	if (policy.requireApprovalAboveCostUsd !== void 0 && (action.costUsd ?? 0) > policy.requireApprovalAboveCostUsd) {
-		requiresApproval = true;
-		reasons.push(`cost ${action.costUsd} exceeds approval threshold ${policy.requireApprovalAboveCostUsd}`);
-	}
-	if (policy.maxActionCostUsd !== void 0 && (action.costUsd ?? 0) > policy.maxActionCostUsd) {
-		blocked = true;
-		reasons.push(`cost ${action.costUsd} exceeds max action cost ${policy.maxActionCostUsd}`);
-	}
-	if (policy.remainingBudgetUsd !== void 0 && (action.costUsd ?? 0) > policy.remainingBudgetUsd) {
-		blocked = true;
-		reasons.push(`cost ${action.costUsd} exceeds remaining budget ${policy.remainingBudgetUsd}`);
-	}
-	if (policy.expectedOutcomeRequired && !action.metadata?.expectedOutcome) {
-		blocked = true;
-		reasons.push("expected outcome is required");
-	}
-	if (policy.killCriteriaRequired && !action.metadata?.killCriteria) {
-		blocked = true;
-		reasons.push("kill criteria are required");
-	}
-	if (policy.autoApproveTypes?.includes(action.type) && requiresApproval) reasons.push(`action type "${action.type}" is auto-approved only when no approval policy applies`);
-	if (!reasons.length) reasons.push(requiresApproval ? "approval required" : "action allowed");
-	const label = blocked || requiresApproval ? {
-		source: "policy",
-		kind: blocked ? "policy_block" : "comment",
-		value: {
-			actionType: action.type,
-			blocked,
-			requiresApproval
-		},
-		reason: reasons.join("; "),
-		severity: blocked ? "critical" : "warning",
-		createdAt: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-		metadata: {
-			action,
-			policy
-		}
-	} : void 0;
-	return {
-		allowed: !blocked,
-		blocked,
-		requiresApproval: !blocked && requiresApproval,
-		reasons,
-		label
-	};
-}
-//#endregion
-//#region src/detectors/index.ts
-/** Same action fingerprint N consecutive steps = a stuck loop (the #1 long-horizon failure mode). */
-function repeatedActionDetector(opts = {}) {
-	const max = opts.maxRepeated ?? 3;
-	const severity = opts.severity ?? "warn";
-	const failureClass = opts.failureClass ?? "tool_recovery_failure";
-	let last;
-	let streak = 0;
-	return {
-		id: "repeated-action",
-		get streak() {
-			return streak;
-		},
-		observe(event) {
-			const fp = event.actionFingerprint;
-			if (fp === void 0) return null;
-			streak = fp === last ? streak + 1 : 1;
-			last = fp;
-			if (max <= 0 || streak < max) return null;
-			return {
-				detector: "repeated-action",
-				severity,
-				failureClass,
-				reason: `stuck: repeated same action for ${streak} step(s)`,
-				streak,
-				...event.label ? { evidence: { action: event.label } } : {}
-			};
-		},
-		reset() {
-			last = void 0;
-			streak = 0;
-		}
-	};
-}
-/** State + score unchanged across N steps = spinning wheels. Compares each step to the previous one,
-*  so prime with the initial state (observe it once before the first real step) to detect on step 1. */
-function noProgressDetector(opts = {}) {
-	const max = opts.maxNoProgress ?? 3;
-	const minScoreDelta = opts.minScoreDelta ?? .001;
-	const severity = opts.severity ?? "warn";
-	const failureClass = opts.failureClass ?? "tool_recovery_failure";
-	let lastState;
-	let lastScore;
-	let streak = 0;
-	return {
-		id: "no-progress",
-		get streak() {
-			return streak;
-		},
-		observe(event) {
-			const stateUnchanged = lastState !== void 0 && lastState === event.stateFingerprint;
-			const scoreFlat = Math.abs((event.score ?? 0) - (lastScore ?? 0)) < minScoreDelta;
-			streak = stateUnchanged && scoreFlat ? streak + 1 : 0;
-			lastState = event.stateFingerprint;
-			lastScore = event.score;
-			if (max <= 0 || streak < max) return null;
-			return {
-				detector: "no-progress",
-				severity,
-				failureClass,
-				reason: `stuck: no state/score progress for ${streak} step(s)`,
-				streak,
-				...event.label ? { evidence: { state: event.label } } : {}
-			};
-		},
-		reset() {
-			lastState = void 0;
-			lastScore = void 0;
-			streak = 0;
-		}
-	};
-}
-/** N consecutive tool errors = the worker is hammering a broken approach. */
-function errorStreakDetector(opts = {}) {
-	const max = opts.maxErrors ?? 3;
-	const severity = opts.severity ?? "warn";
-	const failureClass = opts.failureClass ?? "tool_recovery_failure";
-	let streak = 0;
-	return {
-		id: "error-streak",
-		get streak() {
-			return streak;
-		},
-		observe(event) {
-			if (event.status === void 0) return null;
-			streak = event.status === "error" ? streak + 1 : 0;
-			if (max <= 0 || streak < max) return null;
-			return {
-				detector: "error-streak",
-				severity,
-				failureClass,
-				reason: `stuck: ${streak} consecutive errored step(s)`,
-				streak,
-				...event.label ? { evidence: { lastError: event.label } } : {}
-			};
-		},
-		reset() {
-			streak = 0;
-		}
-	};
-}
-/** Fold one event through many detectors at once; returns every signal that fired this step. The
-*  natural shape for an online pipe watching with a whole panel of detectors. */
-function observeAll(detectors, event) {
-	const signals = [];
-	for (const d of detectors) {
-		const s = d.observe(event);
-		if (s) signals.push(s);
-	}
-	return signals;
-}
-//#endregion
-//#region src/control-runtime.ts
-/**
-* Policy-based agent control runtime.
-*
-* This is the minimal reusable loop behind driver-agent patterns:
-*
-*   observe state -> validate -> decide next action -> act -> observe -> ...
-*
-* It deliberately does not model named "topologies". Direct execution,
-* critic/revise, driver intervention, specialist calls, and human escalation
-* are all just actions chosen by the control policy.
-*/
-const DEFAULT_BUDGET = {
-	maxSteps: 8,
-	maxWallMs: 300 * 1e3
-};
-async function runAgentControlLoop(config) {
-	const budget = normalizeBudget(config.budget);
-	const actionFailure = config.actionFailure ?? "continue";
-	const controller = new AbortController();
-	const upstreamAbort = () => controller.abort(config.signal?.reason);
-	if (config.signal) if (config.signal.aborted) controller.abort(config.signal.reason);
-	else config.signal.addEventListener("abort", upstreamAbort, { once: true });
-	const started = Date.now();
-	const wallTimer = budget.maxWallMs ? setTimeout(() => controller.abort(/* @__PURE__ */ new Error("control runtime wall timeout")), budget.maxWallMs) : void 0;
-	const history = [];
-	const emitter = config.store ? new TraceEmitter(config.store) : void 0;
-	let spentCostUsd = 0;
-	const runtimeErrors = [];
-	const repeatedDetector = repeatedActionDetector({ maxRepeated: config.stopPolicies?.maxRepeatedActions ?? 0 });
-	const progressDetector = noProgressDetector({
-		maxNoProgress: config.stopPolicies?.maxNoProgressSteps ?? 0,
-		minScoreDelta: config.stopPolicies?.minScoreDelta ?? .001
-	});
-	try {
-		if (emitter) await runTrace(runtimeErrors, 0, () => emitter.startRun({
-			scenarioId: config.scenarioId ?? "agent-control-loop",
-			projectId: config.projectId,
-			variantId: config.variantId,
-			layer: "meta",
-			tags: {
-				intent: config.intent.slice(0, 120),
-				maxSteps: String(budget.maxSteps),
-				...budget.maxCostUsd !== void 0 ? { maxCostUsd: String(budget.maxCostUsd) } : {}
-			}
-		}));
-		let state;
-		let evals;
-		try {
-			state = await config.observe({
-				history,
-				abortSignal: controller.signal
-			});
-		} catch (err) {
-			const error = runtimeError("observe", 0, err);
-			runtimeErrors.push(error);
-			return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: error.message,
-				steps: history,
-				finalState: void 0,
-				finalEvals: [],
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "unknown",
-				runtimeErrors,
-				stoppedBy: "runtime-error"
-			});
-		}
-		try {
-			evals = await config.validate({
-				intent: config.intent,
-				state,
-				history,
-				abortSignal: controller.signal
-			});
-			await recordEvalSpans(emitter, evals, "initial", runtimeErrors, 0);
-		} catch (err) {
-			const error = runtimeError("validate", 0, err);
-			runtimeErrors.push(error);
-			return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: error.message,
-				steps: history,
-				finalState: state,
-				finalEvals: [],
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "unknown",
-				runtimeErrors,
-				stoppedBy: "runtime-error"
-			});
-		}
-		progressDetector.observe({
-			stateFingerprint: fingerprintState(state, config.stopPolicies),
-			score: averageScore(evals)
-		});
-		for (let stepIndex = 0; stepIndex < budget.maxSteps; stepIndex++) {
-			if (controller.signal.aborted) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: abortReason(controller.signal),
-				score: void 0,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "timeout",
-				runtimeErrors,
-				stoppedBy: "abort"
-			});
-			const budgetStop = budgetStopDecision(budget, spentCostUsd);
-			if (budgetStop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: budgetStop.reason,
-				score: averageScore(evals),
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "budget_exceeded",
-				runtimeErrors,
-				stoppedBy: "budget"
-			});
-			const ctx = makeContext(config.intent, state, evals, history, budget, stepIndex, started, spentCostUsd, controller.signal, emitter);
-			let stop;
-			try {
-				stop = config.shouldStop ? await config.shouldStop(ctx) : defaultStopDecision(evals);
-			} catch (err) {
-				runtimeErrors.push(runtimeError("stop-policy", stepIndex, err));
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			if (stop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: stop.pass,
-				completed: true,
-				reason: stop.reason,
-				score: stop.score,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: stop.failureClass,
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
-			let decision;
-			try {
-				decision = await config.decide(ctx);
-			} catch (err) {
-				runtimeErrors.push(runtimeError("decide", stepIndex, err));
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			if (decision.type === "stop") {
-				const pass = decision.pass ?? false;
-				return finish(emitter, {
-					intent: config.intent,
-					pass,
-					completed: true,
-					reason: decision.reason,
-					score: decision.score,
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: pass ? void 0 : decision.failureClass ?? "unknown",
-					runtimeErrors,
-					stoppedBy: "policy"
-				});
-			}
-			const actionFingerprint = fingerprintAction(decision.action, config.stopPolicies);
-			const repeatedActionSignal = repeatedDetector.observe({ actionFingerprint });
-			const repeatedActionStreak = repeatedDetector.streak;
-			if (repeatedActionSignal) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: true,
-				reason: repeatedActionSignal.reason,
-				score: averageScore(evals),
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "tool_recovery_failure",
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
-			const beforeState = state;
-			const evalsBefore = evals;
-			const scoreBefore = averageScore(evals);
-			const actionStarted = Date.now();
-			const stepHandle = emitter ? await runTrace(runtimeErrors, stepIndex, () => emitter.tool({
-				name: `control-step-${stepIndex}`,
-				toolName: "agent-control-action",
-				args: decision.action,
-				attributes: {
-					decision: decision.reason ?? "continue",
-					repeatedActionStreak
-				}
-			})) : void 0;
-			let actionOutcome;
-			try {
-				const result = await config.act(decision.action, ctx);
-				const rawCostUsd = config.getActionCostUsd?.({
-					action: decision.action,
-					result,
-					state,
-					evals,
-					history
-				});
-				const costUsd = normalizeActionCostUsd(rawCostUsd, runtimeErrors, stepIndex);
-				if (costUsd !== void 0 && Number.isFinite(costUsd) && costUsd > 0) {
-					spentCostUsd += costUsd;
-					await recordCostBudget(emitter, budget, spentCostUsd, stepHandle, runtimeErrors, stepIndex);
-				}
-				actionOutcome = {
-					ok: true,
-					result,
-					...costUsd !== void 0 ? { costUsd } : {},
-					durationMs: Date.now() - actionStarted
-				};
-			} catch (err) {
-				runtimeErrors.push(runtimeError("act", stepIndex, err));
-				actionOutcome = {
-					ok: false,
-					error: runtimeErrors[runtimeErrors.length - 1].message,
-					durationMs: Date.now() - actionStarted
-				};
-				if (actionFailure === "stop") {
-					await runTrace(runtimeErrors, stepIndex, () => stepHandle?.fail(actionOutcome.error ?? "action failed"));
-					const step = {
-						index: stepIndex,
-						decision,
-						beforeState,
-						afterState: state,
-						evalsBefore,
-						evalsAfter: evals,
-						actionOutcome,
-						startedAt: new Date(actionStarted).toISOString(),
-						endedAt: (/* @__PURE__ */ new Date()).toISOString()
-					};
-					history.push(step);
-					await runOnStep(config.onStep, step, runtimeErrors);
-					return finish(emitter, {
-						intent: config.intent,
-						pass: false,
-						completed: false,
-						reason: actionOutcome.error ?? "action failed",
-						score: averageScore(evals),
-						steps: history,
-						finalState: state,
-						finalEvals: evals,
-						wallMs: Date.now() - started,
-						spentCostUsd,
-						runId: emitter?.runId ?? null,
-						failureClass: "unknown",
-						runtimeErrors,
-						stoppedBy: "runtime-error"
-					});
-				}
-			}
-			try {
-				state = await config.observe({
-					history,
-					abortSignal: controller.signal
-				});
-			} catch (err) {
-				runtimeErrors.push(runtimeError("observe", stepIndex, err));
-				const step = {
-					index: stepIndex,
-					decision,
-					beforeState,
-					afterState: beforeState,
-					evalsBefore,
-					evalsAfter: evals,
-					actionOutcome,
-					startedAt: new Date(actionStarted).toISOString(),
-					endedAt: (/* @__PURE__ */ new Date()).toISOString()
-				};
-				history.push(step);
-				await runTrace(runtimeErrors, stepIndex, () => stepHandle?.fail(runtimeErrors[runtimeErrors.length - 1].message));
-				await runOnStep(config.onStep, step, runtimeErrors);
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: beforeState,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			try {
-				evals = await config.validate({
-					intent: config.intent,
-					state,
-					history,
-					abortSignal: controller.signal
-				});
-				await recordEvalSpans(emitter, evals, `step-${stepIndex}`, runtimeErrors, stepIndex, stepHandle?.span.spanId);
-			} catch (err) {
-				runtimeErrors.push(runtimeError("validate", stepIndex, err));
-				const step = {
-					index: stepIndex,
-					decision,
-					beforeState,
-					afterState: state,
-					evalsBefore,
-					evalsAfter: evals,
-					actionOutcome,
-					startedAt: new Date(actionStarted).toISOString(),
-					endedAt: (/* @__PURE__ */ new Date()).toISOString()
-				};
-				history.push(step);
-				await runTrace(runtimeErrors, stepIndex, () => stepHandle?.fail(runtimeErrors[runtimeErrors.length - 1].message));
-				await runOnStep(config.onStep, step, runtimeErrors);
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			const scoreAfter = averageScore(evals);
-			const stateFingerprint = fingerprintState(state, config.stopPolicies);
-			const noProgressSignal = progressDetector.observe({
-				stateFingerprint,
-				score: scoreAfter
-			});
-			const noProgressStreak = progressDetector.streak;
-			const step = {
-				index: stepIndex,
-				decision,
-				beforeState,
-				afterState: state,
-				evalsBefore,
-				evalsAfter: evals,
-				actionOutcome,
-				startedAt: new Date(actionStarted).toISOString(),
-				endedAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			history.push(step);
-			if (actionOutcome.ok) await runTrace(runtimeErrors, stepIndex, () => stepHandle?.end({ attributes: {
-				actionCostUsd: actionOutcome.costUsd ?? null,
-				spentCostUsd,
-				scoreBefore: scoreBefore ?? null,
-				scoreAfter: scoreAfter ?? null,
-				noProgressStreak
-			} }));
-			else await runTrace(runtimeErrors, stepIndex, () => stepHandle?.fail(actionOutcome.error ?? "action failed", { attributes: {
-				spentCostUsd,
-				noProgressStreak
-			} }));
-			await runOnStep(config.onStep, step, runtimeErrors);
-			if (noProgressSignal) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: true,
-				reason: noProgressSignal.reason,
-				score: scoreAfter,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "tool_recovery_failure",
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
-			const postStepBudgetStop = budgetStopDecision(budget, spentCostUsd);
-			if (postStepBudgetStop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: postStepBudgetStop.reason,
-				score: scoreAfter,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "budget_exceeded",
-				runtimeErrors,
-				stoppedBy: "budget"
-			});
-			const postStepCtx = makeContext(config.intent, state, evals, history, budget, stepIndex + 1, started, spentCostUsd, controller.signal, emitter);
-			let postStepStop;
-			try {
-				postStepStop = config.shouldStop ? await config.shouldStop(postStepCtx) : defaultStopDecision(evals);
-			} catch (err) {
-				runtimeErrors.push(runtimeError("stop-policy", stepIndex + 1, err));
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			if (postStepStop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: postStepStop.pass,
-				completed: true,
-				reason: postStepStop.reason,
-				score: postStepStop.score,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: postStepStop.failureClass,
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
-		}
-		return finish(emitter, {
-			intent: config.intent,
-			pass: false,
-			completed: false,
-			reason: `budget exhausted: maxSteps=${budget.maxSteps}`,
-			steps: history,
-			finalState: state,
-			finalEvals: evals,
-			wallMs: Date.now() - started,
-			spentCostUsd,
-			runId: emitter?.runId ?? null,
-			failureClass: "budget_exceeded",
-			runtimeErrors,
-			stoppedBy: "budget"
-		});
-	} catch (err) {
-		runtimeErrors.push(runtimeError("act", history.length, err));
-		return finish(emitter, {
-			intent: config.intent,
-			pass: false,
-			completed: false,
-			reason: runtimeErrors[runtimeErrors.length - 1].message,
-			steps: history,
-			finalState: void 0,
-			finalEvals: [],
-			wallMs: Date.now() - started,
-			spentCostUsd,
-			runId: emitter?.runId ?? null,
-			failureClass: "unknown",
-			runtimeErrors,
-			stoppedBy: "runtime-error"
-		});
-	} finally {
-		if (wallTimer) clearTimeout(wallTimer);
-		if (config.signal) config.signal.removeEventListener("abort", upstreamAbort);
-	}
-}
-function stopOnNoProgress(maxNoProgressSteps, options = {}) {
-	return {
-		...options,
-		maxNoProgressSteps
-	};
-}
-function stopOnRepeatedAction(maxRepeatedActions, options = {}) {
-	return {
-		...options,
-		maxRepeatedActions
-	};
-}
-function objectiveEval(input) {
-	return {
-		...input,
-		objective: true
-	};
-}
-function subjectiveEval(input) {
-	return {
-		...input,
-		objective: false
-	};
-}
-function normalizeBudget(input) {
-	const raw = {
-		...DEFAULT_BUDGET,
-		...input
-	};
-	if (!Number.isInteger(raw.maxSteps) || raw.maxSteps < 1) throw new RangeError(`ControlRuntime budget.maxSteps must be an integer >= 1, got ${String(raw.maxSteps)}`);
-	const budget = { maxSteps: raw.maxSteps };
-	if (raw.maxWallMs !== void 0) {
-		if (typeof raw.maxWallMs !== "number" || !Number.isFinite(raw.maxWallMs) || raw.maxWallMs <= 0) throw new RangeError(`ControlRuntime budget.maxWallMs must be a positive finite number, got ${String(raw.maxWallMs)}`);
-		budget.maxWallMs = raw.maxWallMs;
-	}
-	if (raw.maxCostUsd !== void 0) {
-		if (typeof raw.maxCostUsd !== "number" || !Number.isFinite(raw.maxCostUsd) || raw.maxCostUsd < 0) throw new RangeError(`ControlRuntime budget.maxCostUsd must be a nonnegative finite number, got ${String(raw.maxCostUsd)}`);
-		budget.maxCostUsd = raw.maxCostUsd;
-	}
-	return budget;
-}
-function normalizeActionCostUsd(costUsd, runtimeErrors, stepIndex) {
-	if (costUsd === void 0) return void 0;
-	if (!Number.isFinite(costUsd) || costUsd < 0) {
-		runtimeErrors.push(runtimeError("act", stepIndex, /* @__PURE__ */ new Error(`invalid action costUsd: ${String(costUsd)}`)));
-		return;
-	}
-	return costUsd;
-}
-function allCriticalPassed(evals) {
-	return evals.every((result) => result.passed || result.severity !== "critical" && result.severity !== "error");
-}
-function makeContext(intent, state, evals, history, budget, stepIndex, started, spentCostUsd, abortSignal, emitter) {
-	return {
-		intent,
-		state,
-		evals,
-		history,
-		budget,
-		stepIndex,
-		wallMs: Date.now() - started,
-		spentCostUsd,
-		remainingCostUsd: budget.maxCostUsd === void 0 ? void 0 : Math.max(0, budget.maxCostUsd - spentCostUsd),
-		abortSignal,
-		emitter
-	};
-}
-function defaultStopDecision(evals) {
-	if (!evals.length) return {
-		stop: false,
-		pass: false,
-		reason: "no evals yet"
-	};
-	return allCriticalPassed(evals) ? {
-		stop: true,
-		pass: true,
-		reason: "all critical evals passed",
-		score: averageScore(evals)
-	} : {
-		stop: false,
-		pass: false,
-		reason: "critical evals still failing",
-		score: averageScore(evals)
-	};
-}
-function averageScore(evals) {
-	const scored = evals.map((result) => result.score).filter((score) => typeof score === "number");
-	if (!scored.length) return void 0;
-	return Math.round(scored.reduce((sum, score) => sum + score, 0) / scored.length * 1e3) / 1e3;
-}
-function budgetStopDecision(budget, spentCostUsd) {
-	if (budget.maxCostUsd !== void 0 && spentCostUsd >= budget.maxCostUsd) return {
-		stop: true,
-		reason: `budget exhausted: maxCostUsd=${budget.maxCostUsd}`
-	};
-	return {
-		stop: false,
-		reason: ""
-	};
-}
-async function recordCostBudget(emitter, budget, spentCostUsd, handle, runtimeErrors, stepIndex) {
-	if (!emitter || budget.maxCostUsd === void 0) return;
-	const maxCostUsd = budget.maxCostUsd;
-	await runTrace(runtimeErrors, stepIndex, () => emitter.recordBudget({
-		dimension: "usd",
-		limit: maxCostUsd,
-		consumed: spentCostUsd,
-		remaining: Math.max(0, maxCostUsd - spentCostUsd),
-		breached: spentCostUsd >= maxCostUsd,
-		spanId: handle?.span.spanId
-	}));
-}
-async function recordEvalSpans(emitter, evals, phase, runtimeErrors, stepIndex, targetSpanId) {
-	if (!emitter) return;
-	for (const result of evals) await runTrace(runtimeErrors, stepIndex, () => emitter.recordJudge({
-		judgeId: result.objective ? "objective-validator" : "subjective-judge",
-		targetSpanId: targetSpanId ?? emitter.runId,
-		name: `control-eval/${result.id}`,
-		dimension: result.id,
-		score: typeof result.score === "number" ? result.score : result.passed ? 1 : 0,
-		rationale: result.detail,
-		evidence: result.evidence,
-		attributes: {
-			phase,
-			passed: result.passed,
-			severity: result.severity,
-			objective: result.objective
-		}
-	}));
-}
-async function runOnStep(onStep, step, runtimeErrors) {
-	if (!onStep) return;
-	try {
-		await onStep(step);
-	} catch (err) {
-		runtimeErrors.push(runtimeError("on-step", step.index, err));
-	}
-}
-async function runTrace(runtimeErrors, stepIndex, write) {
-	try {
-		return await write();
-	} catch (err) {
-		runtimeErrors.push(runtimeError("trace", stepIndex, err));
-		return;
-	}
-}
-function fingerprintState(state, policies) {
-	if (policies?.stateFingerprint) return policies.stateFingerprint(state);
-	return stableFingerprint(state);
-}
-function fingerprintAction(action, policies) {
-	if (policies?.actionFingerprint) return policies.actionFingerprint(action);
-	return stableFingerprint(action);
-}
-function stableFingerprint(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean" || value == null) return String(value);
-	try {
-		return JSON.stringify(sortForFingerprint(value));
-	} catch {
-		return String(value);
-	}
-}
-function sortForFingerprint(value) {
-	if (Array.isArray(value)) return value.map(sortForFingerprint);
-	if (!value || typeof value !== "object") return value;
-	const record = value;
-	const sorted = {};
-	for (const key of Object.keys(record).sort()) sorted[key] = sortForFingerprint(record[key]);
-	return sorted;
-}
-function abortReason(signal) {
-	const reason = signal.reason;
-	if (reason instanceof Error) return reason.message;
-	return reason ? String(reason) : "aborted";
-}
-function runtimeError(phase, stepIndex, err) {
-	return {
-		phase,
-		stepIndex,
-		message: err instanceof Error ? err.message : String(err)
-	};
-}
-async function finish(emitter, result) {
-	await runTrace(result.runtimeErrors, result.steps.length, () => emitter?.endRun({
-		pass: result.pass,
-		score: result.score ?? averageScore(result.finalEvals),
-		failureClass: result.failureClass,
-		notes: result.reason
-	}));
-	return result;
-}
-//#endregion
-//#region src/run-evidence.ts
-/**
-* Project a completed control-loop run into the strict RunRecord shape used by
-* release gates, optimizer tables, and research reports.
-*
-* The control loop owns live execution evidence. The caller still supplies the
-* experiment-cell metadata because prompt/config hashes, split assignment,
-* model snapshot, and commit SHA are product/harness concerns.
-*/
-function controlRunToRunRecord(run, options) {
-	const score = finiteScore(options.score) ?? finiteScore(run.score) ?? scoreFromEvals(run.finalEvals);
-	const outcome = options.splitTag === "holdout" ? {
-		...score !== void 0 ? { holdoutScore: score } : {},
-		raw: normalizeRawMetrics(options.raw, run, score)
-	} : {
-		...score !== void 0 ? { searchScore: score } : {},
-		raw: normalizeRawMetrics(options.raw, run, score)
-	};
-	const terminalOutcome = run.stoppedBy === "abort" ? "cancelled" : run.stoppedBy === "runtime-error" ? "failed" : run.completed ? "succeeded" : "incomplete";
-	const costUsd = options.costProvenance.kind === "uncaptured" ? null : options.costProvenance.usd;
-	if (costUsd !== null && costUsd !== run.spentCostUsd) throw new Error(`cost provenance amount ${costUsd} does not match control run spend ${run.spentCostUsd}`);
-	return validateRunRecord({
-		runId: options.runId ?? run.runId ?? `control:${options.experimentId}:${options.candidateId}:${options.seed}:${options.splitTag}`,
-		experimentId: options.experimentId,
-		candidateId: options.candidateId,
-		seed: options.seed,
-		model: options.model,
-		promptHash: options.promptHash,
-		configHash: options.configHash,
-		commitSha: options.commitSha,
-		wallMs: run.wallMs,
-		...options.queueMs !== void 0 ? { queueMs: options.queueMs } : {},
-		costUsd,
-		costProvenance: options.costProvenance,
-		tokenUsage: options.tokenUsage,
-		terminalOutcome,
-		...terminalOutcome !== "succeeded" ? { terminalFailureReason: run.reason } : {},
-		...options.judgeMetadata ? { judgeMetadata: options.judgeMetadata } : {},
-		outcome,
-		...options.failureClass !== void 0 ? { failureClass: options.failureClass } : {},
-		...options.failureMode !== void 0 ? { failureMode: options.failureMode } : {},
-		splitTag: options.splitTag,
-		scenarioId: options.scenarioId
-	});
-}
-function scoreFromEvals(evals) {
-	const scores = evals.map((e) => e.score).filter((score) => typeof score === "number" && Number.isFinite(score));
-	if (scores.length === 0) return void 0;
-	return clampScore(scores.reduce((sum, score) => sum + score, 0) / scores.length);
-}
-function normalizeRawMetrics(raw, run, score) {
-	const normalizedRaw = finiteOnly(raw ?? {});
-	delete normalizedRaw.score;
-	return {
-		...normalizedRaw,
-		...score !== void 0 ? { score } : {},
-		pass: run.pass ? 1 : 0,
-		completed: run.completed ? 1 : 0,
-		steps: run.steps.length,
-		runtimeErrors: run.runtimeErrors.length,
-		execution_error_count: executionErrorCount(run)
-	};
-}
-function executionErrorCount(run) {
-	const thrownActionSteps = new Set(run.runtimeErrors.filter((error) => error.phase === "act").map((error) => error.stepIndex));
-	const failedActionsWithoutRuntimeError = run.steps.filter((step) => step.actionOutcome?.ok === false && !thrownActionSteps.has(step.index)).length;
-	return run.runtimeErrors.length + failedActionsWithoutRuntimeError;
-}
-function finiteOnly(values) {
-	const out = {};
-	for (const [key, value] of Object.entries(values)) if (Number.isFinite(value)) out[key] = value;
-	return out;
-}
-function finiteScore(value) {
-	return value !== void 0 && Number.isFinite(value) ? clampScore(value) : void 0;
-}
-function clampScore(value) {
-	return Math.max(0, Math.min(1, value));
-}
-//#endregion
-//#region src/propose-review.ts
-/**
-* Propose / Verify / Review — the core multi-shot primitive.
-*
-*   shot N:  propose(state, priorReview) → new state
-*            verify(state)               → pass/fail, optional layers
-*            review(state, verification, memory) → observations + next-shot
-*                                                   instruction + shouldContinue
-*            memory.append(entry)
-*
-* Roles are strictly separated:
-*
-*   - The WORKER is whatever the caller wraps in `propose`. It is
-*     stateful — caller owns its resume/session mechanism.
-*   - The VERIFIER grades the state. It produces the ground truth.
-*     The reviewer cannot overturn or downgrade a verification layer.
-*   - The REVIEWER is stateless per call. Its continuity is the
-*     `ReviewMemoryStore` — durable JSONL by default, or any store
-*     implementing the interface. It reads memory + trace summary +
-*     verification and directs the NEXT proposer shot.
-*
-* This shape is load-bearing. The reviewer never grades; the verifier
-* never directs. Two processes, two prompts, two concerns — which is
-* what keeps the loop from confirmation-biasing itself into "all
-* passed" when it didn't.
-*
-* Short-circuits and soft-fails are both first-class:
-*   - verify.pass === true  → reviewer LLM call is skipped, memory
-*     records a success entry, loop exits.
-*   - review throws         → the shot still counts; the loop uses the
-*     last-known instruction (or `fallbackInstruction`) for the next
-*     propose call. A transient reviewer failure must NEVER abort a
-*     valid arc.
-*
-* Composable: `propose` itself can be another `runProposeReview` call.
-* That's the dogfooding path — a harness built on this primitive is in
-* turn evaluable by it.
-*/
-function inMemoryReviewStore(initial = []) {
-	const entries = [...initial];
-	return {
-		async load() {
-			return [...entries];
-		},
-		async append(entry) {
-			entries.push(entry);
-		}
-	};
-}
-function jsonlReviewStore(path) {
-	return {
-		async load() {
-			if (!existsSync(path)) return [];
-			const raw = readFileSync(path, "utf8");
-			const out = [];
-			for (const line of raw.split("\n")) {
-				const trimmed = line.trim();
-				if (!trimmed) continue;
-				try {
-					out.push(JSON.parse(trimmed));
-				} catch {}
-			}
-			return out;
-		},
-		async append(entry) {
-			mkdirSync(dirname(path), { recursive: true });
-			appendFileSync(path, `${JSON.stringify(entry)}\n`);
-		}
-	};
-}
-const DEFAULT_FALLBACK_INSTRUCTION$1 = "Inspect the verification failures above. Fix the critical issues first, then the major ones. Do not restate the failures — act on them.";
-async function runProposeReview(config) {
-	const maxShots = config.maxShots ?? 10;
-	const maxWallMs = config.maxWallMs ?? 600 * 1e3;
-	const confidenceFloor = config.confidenceFloor ?? .3;
-	const confidenceFloorWindow = config.confidenceFloorWindow ?? 2;
-	const memory = config.memory ?? inMemoryReviewStore();
-	const fallbackInstruction = config.fallbackInstruction ?? DEFAULT_FALLBACK_INSTRUCTION$1;
-	const emitter = config.store ? new TraceEmitter(config.store) : null;
-	if (emitter) await emitter.startRun({
-		scenarioId: config.scenarioId ?? "propose-review",
-		projectId: config.projectId,
-		variantId: config.variantId,
-		layer: "meta",
-		tags: {
-			goal: config.goal.slice(0, 120),
-			maxShots: String(maxShots)
-		}
-	});
-	const abort = new AbortController();
-	const wallStart = Date.now();
-	const wallTimer = setTimeout(() => abort.abort(/* @__PURE__ */ new Error("propose-review wall timeout")), maxWallMs);
-	const shots = [];
-	let state = config.initialState;
-	let priorReview = null;
-	let lastVerification = { pass: false };
-	let failureClass;
-	let completed = false;
-	let lowConfidenceStreak = 0;
-	try {
-		for (let shot = 1; shot <= maxShots; shot++) {
-			if (abort.signal.aborted) {
-				failureClass = "timeout";
-				break;
-			}
-			const shotStart = Date.now();
-			const shotHandle = emitter ? await emitter.span({
-				kind: "tool",
-				name: `shot-${shot}`
-			}) : null;
-			let proposeOut;
-			try {
-				proposeOut = await config.propose({
-					shot,
-					goal: config.goal,
-					state,
-					priorReview,
-					abortSignal: abort.signal,
-					emitter: emitter ?? void 0
-				});
-			} catch (err) {
-				await shotHandle?.fail(err instanceof Error ? err : String(err));
-				failureClass = "unknown";
-				throw err;
-			}
-			state = proposeOut.state;
-			const traceSummary = proposeOut.traceSummary;
-			let verification;
-			try {
-				verification = await config.verify(state);
-			} catch (err) {
-				await shotHandle?.fail(err instanceof Error ? err : String(err));
-				failureClass = "unknown";
-				throw err;
-			}
-			lastVerification = verification;
-			const memorySnapshot = await memory.load();
-			const verificationDigest = {
-				pass: verification.pass,
-				score: verification.score,
-				failingLayers: verification.failingLayers ?? []
-			};
-			let review;
-			let reviewAvailable = true;
-			let reviewError;
-			if (verification.pass) review = {
-				observations: "verification passed — skipping reviewer LLM call",
-				diagnosis: "no failures to diagnose",
-				nextShotInstruction: "(done)",
-				shouldContinue: false,
-				confidence: 1
-			};
-			else try {
-				review = await config.review({
-					shot,
-					goal: config.goal,
-					state,
-					verification,
-					traceSummary,
-					memory: memorySnapshot
-				});
-				review = coerceReview(review);
-			} catch (err) {
-				reviewAvailable = false;
-				reviewError = err instanceof Error ? err.message : String(err);
-				const lastInstruction = memorySnapshot.length > 0 ? memorySnapshot[memorySnapshot.length - 1].nextShotInstruction : fallbackInstruction;
-				review = {
-					observations: "(reviewer unavailable — using last-known instruction)",
-					diagnosis: reviewError,
-					nextShotInstruction: lastInstruction,
-					shouldContinue: true,
-					confidence: .3
-				};
-			}
-			const entry = {
-				shot,
-				timestamp: Date.now(),
-				...review,
-				verification: verificationDigest
-			};
-			await memory.append(entry);
-			const shotRecord = {
-				shot,
-				state,
-				verification,
-				traceSummary,
-				review,
-				reviewAvailable,
-				reviewError,
-				durationMs: Date.now() - shotStart
-			};
-			shots.push(shotRecord);
-			await shotHandle?.end({ attributes: {
-				verificationPass: verification.pass,
-				verificationScore: verification.score ?? null,
-				reviewShouldContinue: review.shouldContinue,
-				reviewConfidence: review.confidence,
-				reviewAvailable
-			} });
-			if (verification.pass) {
-				completed = true;
-				break;
-			}
-			if (!review.shouldContinue) break;
-			if (confidenceFloorWindow > 0 && review.confidence <= confidenceFloor) {
-				lowConfidenceStreak += 1;
-				if (lowConfidenceStreak >= confidenceFloorWindow) break;
-			} else lowConfidenceStreak = 0;
-			priorReview = review;
-		}
-		if (!completed && !failureClass) failureClass = shots.length >= maxShots ? "budget_exceeded" : "unknown";
-	} finally {
-		clearTimeout(wallTimer);
-	}
-	const score = lastVerification.pass ? 1 : typeof lastVerification.score === "number" ? lastVerification.score : 0;
-	if (emitter) await emitter.endRun({
-		pass: completed,
-		score,
-		failureClass,
-		notes: `${shots.length} shot(s); final pass=${lastVerification.pass}`
-	});
-	return {
-		runId: emitter?.runId ?? null,
-		completed,
-		shots,
-		finalState: state,
-		finalVerification: lastVerification,
-		failureClass,
-		wallMs: Date.now() - wallStart,
-		score
-	};
-}
-const REVIEWER_SYSTEM_PROMPT = `You are a senior reviewer directing a multi-shot build loop.
-You do NOT grade — the verifier already did. Your job is to direct the worker's next shot.
-You are blind to the worker's inner monologue. You see what it DID, not what it thought.
-Return STRICT JSON matching the schema. No prose outside the JSON.`;
-function createLlmReviewer(cfg) {
-	const renderState = cfg.renderState ?? ((s) => safeJson(s));
-	const renderTraceSummary = cfg.renderTraceSummary ?? ((s) => s === void 0 ? "(none)" : safeJson(s));
-	const system = cfg.systemPromptAddendum ? `${REVIEWER_SYSTEM_PROMPT}\n\n${cfg.systemPromptAddendum}` : REVIEWER_SYSTEM_PROMPT;
-	return async (input) => {
-		const memoryBlock = input.memory.length === 0 ? "(no prior shots — this is shot 1)" : input.memory.map((m) => [
-			`shot ${m.shot} — verification.pass=${m.verification.pass}` + (typeof m.verification.score === "number" ? ` score=${m.verification.score.toFixed(2)}` : "") + ` confidence=${m.confidence.toFixed(2)} failing=[${(m.verification.failingLayers ?? []).join(",")}]`,
-			`  observations: ${m.observations.slice(0, 400)}`,
-			`  diagnosis: ${m.diagnosis.slice(0, 400)}`,
-			`  instruction given: ${m.nextShotInstruction.slice(0, 400)}`
-		].join("\n")).join("\n\n");
-		const user = [
-			`=== GOAL ===`,
-			input.goal,
-			``,
-			`=== SHOT NUMBER ===`,
-			String(input.shot),
-			``,
-			`=== CURRENT STATE ===`,
-			renderState(input.state),
-			``,
-			`=== TRACE SUMMARY ===`,
-			renderTraceSummary(input.traceSummary),
-			``,
-			`=== VERIFICATION ===`,
-			summarizeVerification(input.verification),
-			``,
-			`=== REVIEWER MEMORY (prior shots) ===`,
-			memoryBlock,
-			``,
-			`=== YOUR TASK ===`,
-			`Return STRICT JSON:`,
-			`{`,
-			`  "observations": string (20..2000 chars, first-person worker behavior — quote counts, errors, loops)`,
-			`  "diagnosis": string (20..1500 chars, root cause, NOT a restatement of verification)`,
-			`  "nextShotInstruction": string (40..3000 chars, concrete directive to the worker)`,
-			`  "shouldContinue": boolean (false if verification.pass, or if thrashing, or unachievable)`,
-			`  "confidence": number in [0,1]`,
-			`}`
-		].join("\n");
-		return coerceReview(await cfg.callJson({
-			system,
-			user
-		}));
-	};
-}
-function coerceReview(raw) {
-	if (!raw || typeof raw !== "object") throw new Error("reviewer returned non-object");
-	const observations = typeof raw.observations === "string" ? raw.observations : "";
-	const diagnosis = typeof raw.diagnosis === "string" ? raw.diagnosis : "";
-	const nextShotInstruction = typeof raw.nextShotInstruction === "string" ? raw.nextShotInstruction : "";
-	if (!observations || !diagnosis || !nextShotInstruction) throw new Error("reviewer missing required string fields");
-	if (typeof raw.shouldContinue !== "boolean") throw new Error("reviewer missing shouldContinue boolean");
-	const confidenceRaw = Number(raw.confidence);
-	if (!Number.isFinite(confidenceRaw)) throw new Error("reviewer confidence not finite");
-	return {
-		observations,
-		diagnosis,
-		nextShotInstruction,
-		shouldContinue: raw.shouldContinue,
-		confidence: Math.max(0, Math.min(1, confidenceRaw))
-	};
-}
-function summarizeVerification(v) {
-	return `pass=${v.pass}` + (typeof v.score === "number" ? ` score=${v.score.toFixed(3)}` : "") + (v.failingLayers && v.failingLayers.length > 0 ? ` failing=[${v.failingLayers.join(", ")}]` : "") + (v.details === void 0 ? "" : `\n${safeJson(v.details).slice(0, 1500)}`);
-}
-function safeJson(x) {
-	try {
-		return JSON.stringify(x, null, 2);
-	} catch {
-		return String(x);
-	}
-}
-//#endregion
-//#region src/propose-review-control.ts
-const DEFAULT_FALLBACK_INSTRUCTION = "Inspect the verification failures above. Fix the critical issues first, then the major ones. Do not restate the failures — act on them.";
-async function runProposeReviewAsControlLoop(config) {
-	const maxShots = config.maxShots ?? 10;
-	const confidenceFloor = config.confidenceFloor ?? .3;
-	const confidenceFloorWindow = config.confidenceFloorWindow ?? 2;
-	const memory = config.memory ?? inMemoryReviewStore();
-	const fallbackInstruction = config.fallbackInstruction ?? DEFAULT_FALLBACK_INSTRUCTION;
-	const failureClassFromVerification = config.failureClassFromVerification ?? controlFailureClassFromVerification;
-	let lowConfidenceStreak = 0;
-	let current = {
-		shot: 0,
-		state: config.initialState,
-		priorReview: null,
-		verification: { pass: false },
-		memory: await memory.load(),
-		completed: false,
-		reviewAvailable: false
-	};
-	return runAgentControlLoop({
-		intent: config.goal,
-		budget: {
-			maxSteps: maxShots,
-			maxWallMs: config.maxWallMs
-		},
-		store: config.store,
-		scenarioId: config.scenarioId ?? "propose-review-control",
-		projectId: config.projectId,
-		variantId: config.variantId,
-		actionFailure: config.actionFailure ?? "stop",
-		observe: () => current,
-		validate: ({ state }) => [objectiveEval({
-			id: "verification",
-			passed: state.verification.pass,
-			score: state.verification.score,
-			severity: "critical",
-			detail: state.verification.pass ? "verification passed" : `verification failed${state.verification.failingLayers?.length ? `: ${state.verification.failingLayers.join(", ")}` : ""}`
-		})],
-		shouldStop: ({ state }) => {
-			if (state.verification.pass) return {
-				stop: true,
-				pass: true,
-				reason: "verification passed",
-				score: state.verification.score
-			};
-			if (state.completed) return {
-				stop: true,
-				pass: false,
-				reason: "reviewer stopped continuation",
-				score: state.verification.score,
-				failureClass: failureClassFromVerification(state.verification)
-			};
-			return {
-				stop: false,
-				pass: false,
-				reason: "verification still failing",
-				score: state.verification.score
-			};
-		},
-		decide: ({ state }) => ({
-			type: "continue",
-			action: {
-				type: "propose-review-shot",
-				shot: state.shot + 1
-			},
-			reason: state.priorReview?.nextShotInstruction ?? fallbackInstruction
-		}),
-		act: async (action, ctx) => {
-			const shot = action.shot;
-			const proposeOut = await config.propose({
-				shot,
-				goal: config.goal,
-				state: current.state,
-				priorReview: current.priorReview,
-				abortSignal: ctx.abortSignal,
-				emitter: ctx.emitter
-			});
-			const nextState = proposeOut.state;
-			const verification = await config.verify(nextState);
-			let review = null;
-			let reviewAvailable = false;
-			let reviewError;
-			let shouldContinue = !verification.pass;
-			if (!verification.pass) try {
-				review = await config.review({
-					shot,
-					goal: config.goal,
-					state: nextState,
-					verification,
-					traceSummary: proposeOut.traceSummary,
-					memory: await memory.load()
-				});
-				reviewAvailable = true;
-				shouldContinue = review.shouldContinue;
-				lowConfidenceStreak = review.confidence <= confidenceFloor ? lowConfidenceStreak + 1 : 0;
-				if (confidenceFloorWindow > 0 && lowConfidenceStreak >= confidenceFloorWindow) shouldContinue = false;
-			} catch (err) {
-				reviewError = err instanceof Error ? err.message : String(err);
-				review = current.priorReview ?? {
-					observations: "Reviewer unavailable.",
-					diagnosis: reviewError,
-					nextShotInstruction: fallbackInstruction,
-					shouldContinue: true,
-					confidence: 0
-				};
-				shouldContinue = true;
-			}
-			else review = {
-				observations: "Verification passed.",
-				diagnosis: "No further revision needed.",
-				nextShotInstruction: "",
-				shouldContinue: false,
-				confidence: 1
-			};
-			const entry = {
-				...review ?? {
-					observations: "No review.",
-					diagnosis: "",
-					nextShotInstruction: fallbackInstruction,
-					shouldContinue,
-					confidence: 0
-				},
-				shot,
-				timestamp: Date.now(),
-				verification: {
-					pass: verification.pass,
-					score: verification.score,
-					failingLayers: verification.failingLayers
-				}
-			};
-			await memory.append(entry);
-			current = {
-				shot,
-				state: nextState,
-				priorReview: review,
-				verification,
-				traceSummary: proposeOut.traceSummary,
-				memory: await memory.load(),
-				completed: verification.pass || !shouldContinue,
-				reviewAvailable,
-				reviewError
-			};
-			return {
-				state: nextState,
-				verification,
-				traceSummary: proposeOut.traceSummary,
-				review,
-				reviewAvailable,
-				reviewError
-			};
-		}
-	});
-}
-function controlFailureClassFromVerification(verification) {
-	if (verification.pass) return void 0;
-	return verification.failingLayers?.length ? "instruction_following" : "unknown";
-}
-//#endregion
-export { observeAll as _, jsonlReviewStore as a, scoreFromEvals as c, runAgentControlLoop as d, stopOnNoProgress as f, noProgressDetector as g, errorStreakDetector as h, inMemoryReviewStore as i, allCriticalPassed as l, subjectiveEval as m, runProposeReviewAsControlLoop as n, runProposeReview as o, stopOnRepeatedAction as p, createLlmReviewer as r, controlRunToRunRecord as s, controlFailureClassFromVerification as t, objectiveEval as u, repeatedActionDetector as v, evaluateActionPolicy as y };
-
-//# sourceMappingURL=propose-review-control-dSNPjFUH.js.map