@tangle-network/agent-eval 0.129.0 → 0.130.0

package/dist/chunk-WVATSFCP.js

@@ -1,1553 +0,0 @@
-import {
-  TraceEmitter
-} from "./chunk-VQMK5FMP.js";
-import {
-  validateRunRecord
-} from "./chunk-56TAVBOK.js";
-
-// 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
-  };
-}
-
-// src/detectors/index.ts
-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;
-    }
-  };
-}
-function noProgressDetector(opts = {}) {
-  const max = opts.maxNoProgress ?? 3;
-  const minScoreDelta = opts.minScoreDelta ?? 1e-3;
-  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;
-    }
-  };
-}
-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;
-    }
-  };
-}
-function observeAll(detectors, event) {
-  const signals = [];
-  for (const d of detectors) {
-    const s = d.observe(event);
-    if (s) signals.push(s);
-  }
-  return signals;
-}
-
-// src/control-runtime.ts
-var DEFAULT_BUDGET = {
-  maxSteps: 8,
-  maxWallMs: 5 * 60 * 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(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 ?? 1e-3
-  });
-  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 step2 = {
-            index: stepIndex,
-            decision,
-            beforeState,
-            afterState: state,
-            evalsBefore,
-            evalsAfter: evals,
-            actionOutcome,
-            startedAt: new Date(actionStarted).toISOString(),
-            endedAt: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          history.push(step2);
-          await runOnStep(config.onStep, step2, 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 step2 = {
-          index: stepIndex,
-          decision,
-          beforeState,
-          afterState: beforeState,
-          evalsBefore,
-          evalsAfter: evals,
-          actionOutcome,
-          startedAt: new Date(actionStarted).toISOString(),
-          endedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        history.push(step2);
-        await runTrace(
-          runtimeErrors,
-          stepIndex,
-          () => stepHandle?.fail(runtimeErrors[runtimeErrors.length - 1].message)
-        );
-        await runOnStep(config.onStep, step2, 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 step2 = {
-          index: stepIndex,
-          decision,
-          beforeState,
-          afterState: state,
-          evalsBefore,
-          evalsAfter: evals,
-          actionOutcome,
-          startedAt: new Date(actionStarted).toISOString(),
-          endedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        history.push(step2);
-        await runTrace(
-          runtimeErrors,
-          stepIndex,
-          () => stepHandle?.fail(runtimeErrors[runtimeErrors.length - 1].message)
-        );
-        await runOnStep(config.onStep, step2, 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, new Error(`invalid action costUsd: ${String(costUsd)}`))
-    );
-    return void 0;
-  }
-  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" };
-  const pass = allCriticalPassed(evals);
-  return pass ? { 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 void 0;
-  }
-}
-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) {
-  const message = err instanceof Error ? err.message : String(err);
-  return { phase, stepIndex, message };
-}
-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;
-}
-
-// src/run-evidence.ts
-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));
-}
-
-// src/propose-review.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { dirname } from "path";
-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)}
-`);
-    }
-  };
-}
-var DEFAULT_FALLBACK_INSTRUCTION = "Inspect the verification failures above. Fix the critical issues first, then the major ones. Do not restate the failures \u2014 act on them.";
-async function runProposeReview(config) {
-  const maxShots = config.maxShots ?? 10;
-  const maxWallMs = config.maxWallMs ?? 10 * 60 * 1e3;
-  const confidenceFloor = config.confidenceFloor ?? 0.3;
-  const confidenceFloorWindow = config.confidenceFloorWindow ?? 2;
-  const memory = config.memory ?? inMemoryReviewStore();
-  const fallbackInstruction = config.fallbackInstruction ?? DEFAULT_FALLBACK_INSTRUCTION;
-  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(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 \u2014 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 \u2014 using last-known instruction)",
-            diagnosis: reviewError,
-            nextShotInstruction: lastInstruction,
-            shouldContinue: true,
-            confidence: 0.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
-  };
-}
-var REVIEWER_SYSTEM_PROMPT = `You are a senior reviewer directing a multi-shot build loop.
-You do NOT grade \u2014 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}
-
-${cfg.systemPromptAddendum}` : REVIEWER_SYSTEM_PROMPT;
-  return async (input) => {
-    const memoryBlock = input.memory.length === 0 ? "(no prior shots \u2014 this is shot 1)" : input.memory.map(
-      (m) => [
-        `shot ${m.shot} \u2014 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 \u2014 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");
-    const raw = await cfg.callJson({ system, user });
-    return coerceReview(raw);
-  };
-}
-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) {
-  const header = `pass=${v.pass}` + (typeof v.score === "number" ? ` score=${v.score.toFixed(3)}` : "") + (v.failingLayers && v.failingLayers.length > 0 ? ` failing=[${v.failingLayers.join(", ")}]` : "");
-  const details = v.details === void 0 ? "" : `
-${safeJson(v.details).slice(0, 1500)}`;
-  return header + details;
-}
-function safeJson(x) {
-  try {
-    return JSON.stringify(x, null, 2);
-  } catch {
-    return String(x);
-  }
-}
-
-// src/propose-review-control.ts
-var DEFAULT_FALLBACK_INSTRUCTION2 = "Inspect the verification failures above. Fix the critical issues first, then the major ones. Do not restate the failures \u2014 act on them.";
-async function runProposeReviewAsControlLoop(config) {
-  const maxShots = config.maxShots ?? 10;
-  const confidenceFloor = config.confidenceFloor ?? 0.3;
-  const confidenceFloorWindow = config.confidenceFloorWindow ?? 2;
-  const memory = config.memory ?? inMemoryReviewStore();
-  const fallbackInstruction = config.fallbackInstruction ?? DEFAULT_FALLBACK_INSTRUCTION2;
-  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";
-}
-
-export {
-  evaluateActionPolicy,
-  repeatedActionDetector,
-  noProgressDetector,
-  errorStreakDetector,
-  observeAll,
-  runAgentControlLoop,
-  stopOnNoProgress,
-  stopOnRepeatedAction,
-  objectiveEval,
-  subjectiveEval,
-  allCriticalPassed,
-  controlRunToRunRecord,
-  scoreFromEvals,
-  inMemoryReviewStore,
-  jsonlReviewStore,
-  runProposeReview,
-  createLlmReviewer,
-  runProposeReviewAsControlLoop,
-  controlFailureClassFromVerification
-};
-//# sourceMappingURL=chunk-WVATSFCP.js.map