@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/belief-state/index.js

@@ -1,1912 +1,1819 @@
-import {
-  fromClaudeCodeSession,
-  fromCodexSession,
-  fromKimiCodeSession,
-  fromOpenCodeSession,
-  fromPiSession,
-  observeCodeAgentSession
-} from "../chunk-SZLVEKMJ.js";
-import {
-  calibrationFromPairs
-} from "../chunk-NPCTHQIO.js";
-import {
-  projectRuntimeTrajectoryEvidence
-} from "../chunk-T4SQEITX.js";
-import {
-  offPolicyEstimateAll
-} from "../chunk-VGRCHJON.js";
-import {
-  confidenceInterval
-} from "../chunk-MHELPNRP.js";
-import "../chunk-VI2UW6B6.js";
-import "../chunk-PXE2VKMX.js";
-import {
-  ValidationError
-} from "../chunk-ONWEPEDO.js";
-import "../chunk-PZ5AY32C.js";
-
-// src/belief-state/calibration.ts
+import { s as ValidationError } from "../errors-8YnH8WlF.js";
+import { a as confidenceInterval } from "../statistics-CnnxdpOg.js";
+import { s as trainingScore } from "../reward-nw2xZGZG.js";
+import { n as projectRuntimeTrajectoryEvidence } from "../runtime-trajectory-1gyaTOoC.js";
+import { r as offPolicyEstimateAll } from "../off-policy-DvgzvtIx.js";
+import { n as calibrationFromPairs } from "../calibration-CNWWA6K8.js";
+import { a as fromPiSession, c as observeCodeAgentSession, i as fromOpenCodeSession, n as fromCodexSession, r as fromKimiCodeSession, t as fromClaudeCodeSession } from "../code-agent-session-BjkMTQ7H.js";
+//#region src/belief-state/calibration.ts
 function calibrateBeliefDecisions(points, options = {}) {
-  const filtered = filterCalibrationRegion(points, options);
-  const pairs = filtered.filter((point) => typeof point.confidence === "number" && point.outcome).map((point) => ({
-    evalScore: point.confidence,
-    outcome: outcomeScore(point)
-  })).filter((pair) => Number.isFinite(pair.outcome));
-  const minPairs = options.minPairs ?? 10;
-  if (pairs.length < minPairs) return null;
-  return calibrationFromPairs(pairs, "belief-confidence", "decision-outcome", {
-    bins: options.bins ?? 5,
-    range: { lo: 0, hi: 1 }
-  });
+	const pairs = filterCalibrationRegion(points, options).filter((point) => typeof point.confidence === "number" && point.outcome).map((point) => ({
+		evalScore: point.confidence,
+		outcome: outcomeScore$1(point)
+	})).filter((pair) => Number.isFinite(pair.outcome));
+	const minPairs = options.minPairs ?? 10;
+	if (pairs.length < minPairs) return null;
+	return calibrationFromPairs(pairs, "belief-confidence", "decision-outcome", {
+		bins: options.bins ?? 5,
+		range: {
+			lo: 0,
+			hi: 1
+		}
+	});
 }
 function filterCalibrationRegion(points, options) {
-  const region = options.region ?? "all";
-  if (region === "all") return points;
-  const policy = options.policy;
-  if (!policy) {
-    throw new ValidationError(
-      `calibrateBeliefDecisions: policy is required when region is "${region}"`
-    );
-  }
-  return points.filter((point) => {
-    const accepted = policy.decide(point).action === "accept";
-    return region === "accepted" ? accepted : !accepted;
-  });
-}
-function outcomeScore(point) {
-  if (typeof point.outcome?.reward === "number") return point.outcome.reward;
-  if (typeof point.outcome?.score === "number") return point.outcome.score;
-  if (point.outcome?.success === true) return 1;
-  if (point.outcome?.success === false) return 0;
-  return Number.NaN;
-}
-
-// src/belief-state/ope.ts
+	const region = options.region ?? "all";
+	if (region === "all") return points;
+	const policy = options.policy;
+	if (!policy) throw new ValidationError(`calibrateBeliefDecisions: policy is required when region is "${region}"`);
+	return points.filter((point) => {
+		const accepted = policy.decide(point).action === "accept";
+		return region === "accepted" ? accepted : !accepted;
+	});
+}
+function outcomeScore$1(point) {
+	if (typeof point.outcome?.reward === "number") return point.outcome.reward;
+	if (typeof point.outcome?.score === "number") return point.outcome.score;
+	if (point.outcome?.success === true) return 1;
+	if (point.outcome?.success === false) return 0;
+	return NaN;
+}
+//#endregion
+//#region src/belief-state/ope.ts
 function embeddedBeliefOpeTargetPolicy(id = "embedded-target-prob") {
-  return {
-    id,
-    targetProbOf(point) {
-      return point.targetProb;
-    },
-    qHatChosenOf(point) {
-      return point.qHatChosen;
-    },
-    vHatTargetOf(point) {
-      return point.vHatTarget;
-    },
-    qHatOf(point) {
-      return point.qHat;
-    }
-  };
+	return {
+		id,
+		targetProbOf(point) {
+			return point.targetProb;
+		},
+		qHatChosenOf(point) {
+			return point.qHatChosen;
+		},
+		vHatTargetOf(point) {
+			return point.vHatTarget;
+		}
+	};
 }
 function beliefDecisionsToOffPolicyTrajectories(points, targetPolicy, options = {}) {
-  const trajectories = [];
-  const diagnostics = [];
-  for (const point of points) {
-    if (!point.outcome) {
-      diagnostics.push(`${point.id}: missing outcome`);
-      continue;
-    }
-    if (!isBehaviorProbability(point.behaviorProb)) {
-      diagnostics.push(`${point.id}: invalid behaviorProb ${formatProbability(point.behaviorProb)}`);
-      continue;
-    }
-    let targetProb;
-    let qHatChosen;
-    let vHatTarget;
-    let qHat;
-    try {
-      targetProb = targetPolicy.targetProbOf(point);
-      qHatChosen = targetPolicy.qHatChosenOf?.(point);
-      vHatTarget = targetPolicy.vHatTargetOf?.(point);
-      qHat = targetPolicy.qHatOf?.(point);
-    } catch (error) {
-      diagnostics.push(
-        `${point.id}: target policy ${targetPolicy.id} threw (${errorMessage(error)})`
-      );
-      continue;
-    }
-    if (!isTargetProbability(targetProb)) {
-      diagnostics.push(`${point.id}: invalid targetProb ${formatProbability(targetProb)}`);
-      continue;
-    }
-    const hasQHatChosen = qHatChosen !== null && qHatChosen !== void 0;
-    const hasVHatTarget = vHatTarget !== null && vHatTarget !== void 0;
-    if (hasQHatChosen !== hasVHatTarget) {
-      diagnostics.push(`${point.id}: qHatChosen and vHatTarget must be supplied together`);
-      continue;
-    }
-    if (hasQHatChosen && hasVHatTarget && (!isTargetProbability(qHatChosen) || !isTargetProbability(vHatTarget))) {
-      diagnostics.push(
-        `${point.id}: invalid contextual Q pair qHatChosen=${formatProbability(qHatChosen)} vHatTarget=${formatProbability(vHatTarget)}`
-      );
-      continue;
-    }
-    if (!hasQHatChosen && !hasVHatTarget && qHat !== null && qHat !== void 0 && !isTargetProbability(qHat)) {
-      diagnostics.push(`${point.id}: invalid qHat ${formatProbability(qHat)}; ignoring qHat`);
-      qHat = null;
-    }
-    trajectories.push({
-      runId: point.id,
-      reward: rewardOf(point),
-      behaviorProb: point.behaviorProb,
-      targetProb,
-      ...qHatChosen !== void 0 ? { qHatChosen } : {},
-      ...vHatTarget !== void 0 ? { vHatTarget } : {},
-      qHat
-    });
-  }
-  return {
-    targetPolicyId: targetPolicy.id,
-    trajectories,
-    dropped: points.length - trajectories.length,
-    diagnostics: compactDiagnostics(diagnostics, options.maxDiagnostics ?? 20)
-  };
+	const trajectories = [];
+	const diagnostics = [];
+	for (const point of points) {
+		if (!point.outcome) {
+			diagnostics.push(`${point.id}: missing outcome`);
+			continue;
+		}
+		if (!isBehaviorProbability(point.behaviorProb)) {
+			diagnostics.push(`${point.id}: invalid behaviorProb ${formatProbability(point.behaviorProb)}`);
+			continue;
+		}
+		let targetProb;
+		let qHatChosen;
+		let vHatTarget;
+		try {
+			targetProb = targetPolicy.targetProbOf(point);
+			qHatChosen = targetPolicy.qHatChosenOf?.(point);
+			vHatTarget = targetPolicy.vHatTargetOf?.(point);
+		} catch (error) {
+			diagnostics.push(`${point.id}: target policy ${targetPolicy.id} threw (${errorMessage$1(error)})`);
+			continue;
+		}
+		if (!isTargetProbability(targetProb)) {
+			diagnostics.push(`${point.id}: invalid targetProb ${formatProbability(targetProb)}`);
+			continue;
+		}
+		const hasQHatChosen = qHatChosen !== null && qHatChosen !== void 0;
+		const hasVHatTarget = vHatTarget !== null && vHatTarget !== void 0;
+		if (hasQHatChosen !== hasVHatTarget) {
+			diagnostics.push(`${point.id}: qHatChosen and vHatTarget must be supplied together`);
+			continue;
+		}
+		if (hasQHatChosen && hasVHatTarget && (!isTargetProbability(qHatChosen) || !isTargetProbability(vHatTarget))) {
+			diagnostics.push(`${point.id}: invalid contextual Q pair qHatChosen=${formatProbability(qHatChosen)} vHatTarget=${formatProbability(vHatTarget)}`);
+			continue;
+		}
+		trajectories.push({
+			runId: point.id,
+			reward: rewardOf$1(point),
+			behaviorProb: point.behaviorProb,
+			targetProb,
+			...qHatChosen !== void 0 ? { qHatChosen } : {},
+			...vHatTarget !== void 0 ? { vHatTarget } : {}
+		});
+	}
+	return {
+		targetPolicyId: targetPolicy.id,
+		trajectories,
+		dropped: points.length - trajectories.length,
+		diagnostics: compactDiagnostics(diagnostics, options.maxDiagnostics ?? 20)
+	};
 }
 function evaluateBeliefOffPolicy(points, targetPolicy, options = {}) {
-  const trajectoryReport = beliefDecisionsToOffPolicyTrajectories(points, targetPolicy, options);
-  const { trajectories } = trajectoryReport;
-  const estimates = offPolicyEstimateAll(trajectories, options);
-  const support = supportDiagnostics(estimates.dr, {
-    minEffectiveSampleSize: options.minEffectiveSampleSize ?? 30,
-    minEffectiveSampleRatio: options.minEffectiveSampleRatio ?? 0.25,
-    dropped: trajectoryReport.dropped,
-    diagnostics: trajectoryReport.diagnostics,
-    legacyScalarContributions: estimates.dr.contributionCounts?.legacyScalar ?? 0
-  });
-  return { targetPolicyId: targetPolicy.id, ...estimates, support };
+	const trajectoryReport = beliefDecisionsToOffPolicyTrajectories(points, targetPolicy, options);
+	const { trajectories } = trajectoryReport;
+	const estimates = offPolicyEstimateAll(trajectories, options);
+	const support = supportDiagnostics(estimates.dr, {
+		minEffectiveSampleSize: options.minEffectiveSampleSize ?? 30,
+		minEffectiveSampleRatio: options.minEffectiveSampleRatio ?? .25,
+		dropped: trajectoryReport.dropped,
+		diagnostics: trajectoryReport.diagnostics
+	});
+	return {
+		targetPolicyId: targetPolicy.id,
+		...estimates,
+		support
+	};
 }
 function supportDiagnostics(estimate, options) {
-  const ratio2 = estimate.n > 0 ? estimate.effectiveSampleSize / estimate.n : 0;
-  const reasons = [...options.diagnostics];
-  if (estimate.n === 0) {
-    reasons.push("no valid OPE trajectories");
-  }
-  if (options.dropped > 0) {
-    reasons.push(`dropped ${options.dropped} unsupported decision(s)`);
-  }
-  if (options.legacyScalarContributions > 0) {
-    reasons.push(
-      `${options.legacyScalarContributions} decision(s) used deprecated scalar qHat; supply qHatChosen and vHatTarget for contextual doubly robust estimation`
-    );
-  }
-  if (estimate.effectiveSampleSize < options.minEffectiveSampleSize) {
-    reasons.push(
-      `effective sample size ${estimate.effectiveSampleSize.toFixed(2)} below ${options.minEffectiveSampleSize}`
-    );
-  }
-  if (ratio2 < options.minEffectiveSampleRatio) {
-    reasons.push(
-      `effective sample ratio ${ratio2.toFixed(2)} below ${options.minEffectiveSampleRatio}`
-    );
-  }
-  if (estimate.maxImportanceWeight > 10) {
-    reasons.push(`max importance weight ${estimate.maxImportanceWeight.toFixed(2)} is high`);
-  }
-  return {
-    supported: reasons.length === 0,
-    n: estimate.n,
-    dropped: options.dropped,
-    effectiveSampleSize: estimate.effectiveSampleSize,
-    effectiveSampleRatio: ratio2,
-    maxImportanceWeight: estimate.maxImportanceWeight,
-    reasons
-  };
-}
-function rewardOf(point) {
-  if (typeof point.outcome?.reward === "number") return point.outcome.reward;
-  if (typeof point.outcome?.score === "number") return point.outcome.score;
-  if (point.outcome?.success === true) return 1;
-  return 0;
+	const ratio = estimate.n > 0 ? estimate.effectiveSampleSize / estimate.n : 0;
+	const reasons = [...options.diagnostics];
+	if (estimate.n === 0) reasons.push("no valid OPE trajectories");
+	if (options.dropped > 0) reasons.push(`dropped ${options.dropped} unsupported decision(s)`);
+	if (estimate.effectiveSampleSize < options.minEffectiveSampleSize) reasons.push(`effective sample size ${estimate.effectiveSampleSize.toFixed(2)} below ${options.minEffectiveSampleSize}`);
+	if (ratio < options.minEffectiveSampleRatio) reasons.push(`effective sample ratio ${ratio.toFixed(2)} below ${options.minEffectiveSampleRatio}`);
+	if (estimate.maxImportanceWeight > 10) reasons.push(`max importance weight ${estimate.maxImportanceWeight.toFixed(2)} is high`);
+	return {
+		supported: reasons.length === 0,
+		n: estimate.n,
+		dropped: options.dropped,
+		effectiveSampleSize: estimate.effectiveSampleSize,
+		effectiveSampleRatio: ratio,
+		maxImportanceWeight: estimate.maxImportanceWeight,
+		reasons
+	};
+}
+function rewardOf$1(point) {
+	if (typeof point.outcome?.reward === "number") return point.outcome.reward;
+	if (typeof point.outcome?.score === "number") return point.outcome.score;
+	if (point.outcome?.success === true) return 1;
+	return 0;
 }
 function isBehaviorProbability(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= 1;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= 1;
 }
 function isTargetProbability(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
 }
 function formatProbability(value) {
-  return typeof value === "number" ? String(value) : String(value ?? "missing");
+	return typeof value === "number" ? String(value) : String(value ?? "missing");
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
 }
 function compactDiagnostics(diagnostics, maxDiagnostics) {
-  if (diagnostics.length <= maxDiagnostics) return diagnostics;
-  return [
-    ...diagnostics.slice(0, maxDiagnostics),
-    `${diagnostics.length - maxDiagnostics} additional OPE diagnostic(s) omitted`
-  ];
-}
-
-// src/belief-state/selective.ts
-var DEFAULT_UTILITY = {
-  successUtility: 1,
-  failureUtility: -1,
-  deferUtility: 0,
-  verifyCost: 0.05,
-  askCost: 0.05,
-  retryCost: 0.1,
-  stopUtility: 0,
-  costWeight: 1
+	if (diagnostics.length <= maxDiagnostics) return diagnostics;
+	return [...diagnostics.slice(0, maxDiagnostics), `${diagnostics.length - maxDiagnostics} additional OPE diagnostic(s) omitted`];
+}
+//#endregion
+//#region src/belief-state/selective.ts
+const DEFAULT_UTILITY = {
+	successUtility: 1,
+	failureUtility: -1,
+	deferUtility: 0,
+	verifyCost: .05,
+	askCost: .05,
+	retryCost: .1,
+	stopUtility: 0,
+	costWeight: 1
 };
 function thresholdSelectivePolicy(options) {
-  const threshold = options.confidenceThreshold;
-  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
-    throw new ValidationError(
-      `thresholdSelectivePolicy: confidenceThreshold must be in [0, 1], got ${threshold}`
-    );
-  }
-  const belowThresholdAction = options.belowThresholdAction ?? "verify";
-  return {
-    id: options.id ?? `confidence>=${threshold}`,
-    decide(point) {
-      const confidence = point.confidence ?? 0;
-      return {
-        action: confidence >= threshold ? "accept" : belowThresholdAction,
-        confidence,
-        targetProb: point.targetProb,
-        qHatChosen: point.qHatChosen,
-        vHatTarget: point.vHatTarget,
-        qHat: point.qHat,
-        reason: confidence >= threshold ? "confidence threshold passed" : "confidence threshold failed"
-      };
-    }
-  };
+	const threshold = options.confidenceThreshold;
+	if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) throw new ValidationError(`thresholdSelectivePolicy: confidenceThreshold must be in [0, 1], got ${threshold}`);
+	const belowThresholdAction = options.belowThresholdAction ?? "verify";
+	return {
+		id: options.id ?? `confidence>=${threshold}`,
+		decide(point) {
+			const confidence = point.confidence ?? 0;
+			return {
+				action: confidence >= threshold ? "accept" : belowThresholdAction,
+				confidence,
+				targetProb: point.targetProb,
+				qHatChosen: point.qHatChosen,
+				vHatTarget: point.vHatTarget,
+				reason: confidence >= threshold ? "confidence threshold passed" : "confidence threshold failed"
+			};
+		}
+	};
 }
 function evaluateBeliefSelectivePolicy(points, policy, options = {}) {
-  const utility = { ...DEFAULT_UTILITY, ...options.utility ?? {} };
-  const scored = points.filter((point) => point.outcome);
-  const minN = options.minN ?? 30;
-  const minAccepted = options.minAccepted ?? 5;
-  const minUtilityDelta = options.minUtilityDelta ?? 0;
-  const deltas = [];
-  const acceptedRewards = [];
-  const rejectedRewards = [];
-  let baselineUtility = 0;
-  let policyUtility = 0;
-  let accepted = 0;
-  let acceptedErrors = 0;
-  for (const point of scored) {
-    const baseline = acceptUtility(point, utility);
-    const decision = policy.decide(point);
-    const candidate = policyDecisionUtility(point, decision.action, utility);
-    const reward = rewardOf2(point, utility);
-    baselineUtility += baseline;
-    policyUtility += candidate;
-    deltas.push(candidate - baseline);
-    if (decision.action === "accept") {
-      accepted++;
-      acceptedRewards.push(reward);
-      if (reward < 0) acceptedErrors++;
-    } else {
-      rejectedRewards.push(reward);
-    }
-  }
-  const n = scored.length;
-  const rejected = Math.max(0, n - accepted);
-  const ci = confidenceInterval(deltas, 0.95, { seed: options.seed ?? 17 });
-  const reasons = [];
-  if (n < minN) reasons.push(`need at least ${minN} scored decisions, got ${n}`);
-  if (accepted < minAccepted)
-    reasons.push(`need at least ${minAccepted} accepted decisions, got ${accepted}`);
-  if (ci.lower <= minUtilityDelta) {
-    reasons.push(`utility CI lower bound ${ci.lower.toFixed(4)} does not clear ${minUtilityDelta}`);
-  }
-  const recommendation = n < minN || accepted < minAccepted ? "need_more_data" : ci.lower > minUtilityDelta ? "ship" : "hold";
-  return {
-    policyId: policy.id,
-    n,
-    accepted,
-    rejected,
-    coverage: n > 0 ? accepted / n : 0,
-    acceptedErrorRate: accepted > 0 ? acceptedErrors / accepted : 0,
-    baselineUtility,
-    policyUtility,
-    utilityDelta: policyUtility - baselineUtility,
-    utilityCi95: ci,
-    rejectedMeanReward: rejectedRewards.length > 0 ? mean(rejectedRewards) : null,
-    recommendation,
-    reasons
-  };
+	const utility = {
+		...DEFAULT_UTILITY,
+		...options.utility ?? {}
+	};
+	const scored = points.filter((point) => point.outcome);
+	const minN = options.minN ?? 30;
+	const minAccepted = options.minAccepted ?? 5;
+	const minUtilityDelta = options.minUtilityDelta ?? 0;
+	const deltas = [];
+	const acceptedRewards = [];
+	const rejectedRewards = [];
+	let baselineUtility = 0;
+	let policyUtility = 0;
+	let accepted = 0;
+	let acceptedErrors = 0;
+	for (const point of scored) {
+		const baseline = acceptUtility(point, utility);
+		const decision = policy.decide(point);
+		const candidate = policyDecisionUtility(point, decision.action, utility);
+		const reward = rewardOf(point, utility);
+		baselineUtility += baseline;
+		policyUtility += candidate;
+		deltas.push(candidate - baseline);
+		if (decision.action === "accept") {
+			accepted++;
+			acceptedRewards.push(reward);
+			if (reward < 0) acceptedErrors++;
+		} else rejectedRewards.push(reward);
+	}
+	const n = scored.length;
+	const rejected = Math.max(0, n - accepted);
+	const ci = confidenceInterval(deltas, .95, { seed: options.seed ?? 17 });
+	const reasons = [];
+	if (n < minN) reasons.push(`need at least ${minN} scored decisions, got ${n}`);
+	if (accepted < minAccepted) reasons.push(`need at least ${minAccepted} accepted decisions, got ${accepted}`);
+	if (ci.lower <= minUtilityDelta) reasons.push(`utility CI lower bound ${ci.lower.toFixed(4)} does not clear ${minUtilityDelta}`);
+	const recommendation = n < minN || accepted < minAccepted ? "need_more_data" : ci.lower > minUtilityDelta ? "ship" : "hold";
+	return {
+		policyId: policy.id,
+		n,
+		accepted,
+		rejected,
+		coverage: n > 0 ? accepted / n : 0,
+		acceptedErrorRate: accepted > 0 ? acceptedErrors / accepted : 0,
+		baselineUtility,
+		policyUtility,
+		utilityDelta: policyUtility - baselineUtility,
+		utilityCi95: ci,
+		rejectedMeanReward: rejectedRewards.length > 0 ? mean$2(rejectedRewards) : null,
+		recommendation,
+		reasons
+	};
 }
 function acceptUtility(point, utility) {
-  return rewardOf2(point, utility) - utility.costWeight * (point.costUsd ?? point.outcome?.costUsd ?? 0);
+	return rewardOf(point, utility) - utility.costWeight * (point.costUsd ?? point.outcome?.costUsd ?? 0);
 }
 function policyDecisionUtility(point, action, utility) {
-  if (action === "accept") return acceptUtility(point, utility);
-  if (action === "verify") return utility.deferUtility - utility.verifyCost;
-  if (action === "ask") return utility.deferUtility - utility.askCost;
-  if (action === "retry") return utility.deferUtility - utility.retryCost;
-  if (action === "stop") return utility.stopUtility;
-  return utility.deferUtility;
-}
-function rewardOf2(point, utility) {
-  const outcome = point.outcome;
-  if (!outcome) return utility.failureUtility;
-  if (typeof outcome.reward === "number") return 2 * outcome.reward - 1;
-  if (typeof outcome.score === "number") return 2 * outcome.score - 1;
-  if (outcome.success === true) return utility.successUtility;
-  if (outcome.success === false) return utility.failureUtility;
-  return utility.failureUtility;
-}
-function mean(values) {
-  return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-
-// src/belief-state/report.ts
+	if (action === "accept") return acceptUtility(point, utility);
+	if (action === "verify") return utility.deferUtility - utility.verifyCost;
+	if (action === "ask") return utility.deferUtility - utility.askCost;
+	if (action === "retry") return utility.deferUtility - utility.retryCost;
+	if (action === "stop") return utility.stopUtility;
+	return utility.deferUtility;
+}
+function rewardOf(point, utility) {
+	const outcome = point.outcome;
+	if (!outcome) return utility.failureUtility;
+	if (typeof outcome.reward === "number") return 2 * outcome.reward - 1;
+	if (typeof outcome.score === "number") return 2 * outcome.score - 1;
+	if (outcome.success === true) return utility.successUtility;
+	if (outcome.success === false) return utility.failureUtility;
+	return utility.failureUtility;
+}
+function mean$2(values) {
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+//#endregion
+//#region src/belief-state/report.ts
 function analyzeBeliefPolicy(options) {
-  const selective = evaluateBeliefSelectivePolicy(options.points, options.policy, options.selective);
-  const calibration = calibrateBeliefDecisions(options.points, options.calibration);
-  const opeTargetPolicy = options.ope?.targetPolicy;
-  const ope = opeTargetPolicy ? evaluateBeliefOffPolicy(options.points, opeTargetPolicy, options.ope) : null;
-  const diagnostics = [];
-  const selectiveStatus = selective.recommendation;
-  const calibrationStatus = calibration ? "supported" : "unsupported";
-  const opeRequested = options.requireOpe === true || options.ope !== void 0;
-  const opeStatus = ope ? ope.support.supported ? "supported" : "unsupported" : opeRequested ? "unsupported" : "not_requested";
-  if (!calibration) diagnostics.push("calibration unsupported: not enough confidence/outcome pairs");
-  if (opeRequested && !opeTargetPolicy) diagnostics.push("OPE unsupported: missing target policy");
-  else if (ope && !ope.support.supported)
-    diagnostics.push(...ope.support.reasons.map((reason) => `OPE unsupported: ${reason}`));
-  const status = overallStatus({
-    selectiveStatus,
-    hasCalibration: calibration !== null,
-    opeStatus,
-    opeRequested
-  });
-  return {
-    policyId: options.policy.id,
-    n: options.points.length,
-    status,
-    selectiveStatus,
-    calibrationStatus,
-    opeStatus,
-    ...ope ? { opeTargetPolicyId: ope.targetPolicyId } : {},
-    selective,
-    ...calibration ? { calibration } : {},
-    ...ope ? { ope } : {},
-    diagnostics
-  };
+	const selective = evaluateBeliefSelectivePolicy(options.points, options.policy, options.selective);
+	const calibration = calibrateBeliefDecisions(options.points, options.calibration);
+	const opeTargetPolicy = options.ope?.targetPolicy;
+	const ope = opeTargetPolicy ? evaluateBeliefOffPolicy(options.points, opeTargetPolicy, options.ope) : null;
+	const diagnostics = [];
+	const selectiveStatus = selective.recommendation;
+	const calibrationStatus = calibration ? "supported" : "unsupported";
+	const opeRequested = options.requireOpe === true || options.ope !== void 0;
+	const opeStatus = ope ? ope.support.supported ? "supported" : "unsupported" : opeRequested ? "unsupported" : "not_requested";
+	if (!calibration) diagnostics.push("calibration unsupported: not enough confidence/outcome pairs");
+	if (opeRequested && !opeTargetPolicy) diagnostics.push("OPE unsupported: missing target policy");
+	else if (ope && !ope.support.supported) diagnostics.push(...ope.support.reasons.map((reason) => `OPE unsupported: ${reason}`));
+	const status = overallStatus({
+		selectiveStatus,
+		hasCalibration: calibration !== null,
+		opeStatus,
+		opeRequested
+	});
+	return {
+		policyId: options.policy.id,
+		n: options.points.length,
+		status,
+		selectiveStatus,
+		calibrationStatus,
+		opeStatus,
+		...ope ? { opeTargetPolicyId: ope.targetPolicyId } : {},
+		selective,
+		...calibration ? { calibration } : {},
+		...ope ? { ope } : {},
+		diagnostics
+	};
 }
 function overallStatus(options) {
-  if (options.selectiveStatus === "need_more_data" || !options.hasCalibration) {
-    return "need_more_data";
-  }
-  if (options.selectiveStatus === "hold") return "hold";
-  if (options.opeRequested && options.opeStatus !== "supported") return "hold";
-  return "ship";
-}
-
-// src/belief-state/code-agent-corpus.ts
-var FAILURE_RECOVERY_ACTIONS = ["retry", "verify", "continue", "stop"];
-var TARGET_LABELS = {
-  "failure-recovery": "Failure recovery after tool or patch failure",
-  "tool-selection": "Tool/action selection",
-  "graph-completion": "Graph completion decision"
+	if (options.selectiveStatus === "need_more_data" || !options.hasCalibration) return "need_more_data";
+	if (options.selectiveStatus === "hold") return "hold";
+	if (options.opeRequested && options.opeStatus !== "supported") return "hold";
+	return "ship";
+}
+//#endregion
+//#region src/belief-state/code-agent-corpus.ts
+const FAILURE_RECOVERY_ACTIONS = [
+	"retry",
+	"verify",
+	"continue",
+	"stop"
+];
+const TARGET_LABELS = {
+	"failure-recovery": "Failure recovery after tool or patch failure",
+	"tool-selection": "Tool/action selection",
+	"graph-completion": "Graph completion decision"
 };
 function extractCodeAgentBeliefDecisionPoints(options) {
-  const entries = options.entries.filter(isRecord);
-  const diagnostics = [];
-  const observed = observedActionsFor(options.source, entries, options);
-  const decisions = [];
-  for (const action of observed) {
-    if (action.kind === "tool" || action.kind === "patch") {
-      decisions.push(toolSelectionDecision(action, options));
-    }
-    if (action.kind === "graph-completion") {
-      decisions.push(graphCompletionDecision(action, options));
-    }
-  }
-  for (const failed of observed) {
-    if (failed.kind !== "tool" && failed.kind !== "patch" || failed.success !== false) continue;
-    const next = observed.find(
-      (candidate) => candidate.stepIndex > failed.stepIndex && (candidate.kind === "tool" || candidate.kind === "patch" || candidate.kind === "terminal")
-    );
-    if (!next) {
-      diagnostics.push({
-        runId: options.run.runId,
-        severity: "warning",
-        reason: `${failed.id}: failed action has no observable follow-up decision`
-      });
-      continue;
-    }
-    decisions.push(failureRecoveryDecision(failed, next, options));
-  }
-  if (decisions.length === 0) {
-    diagnostics.push({
-      runId: options.run.runId,
-      severity: "info",
-      reason: `no belief decision points extracted from ${options.source} entries`
-    });
-  }
-  return { decisions, diagnostics };
+	const entries = options.entries.filter(isRecord$2);
+	const diagnostics = [];
+	const observed = observedActionsFor(options.source, entries, options);
+	const decisions = [];
+	for (const action of observed) {
+		if (action.kind === "tool" || action.kind === "patch") decisions.push(toolSelectionDecision(action, options));
+		if (action.kind === "graph-completion") decisions.push(graphCompletionDecision(action, options));
+	}
+	for (const failed of observed) {
+		if (failed.kind !== "tool" && failed.kind !== "patch" || failed.success !== false) continue;
+		const next = observed.find((candidate) => candidate.stepIndex > failed.stepIndex && (candidate.kind === "tool" || candidate.kind === "patch" || candidate.kind === "terminal"));
+		if (!next) {
+			diagnostics.push({
+				runId: options.run.runId,
+				severity: "warning",
+				reason: `${failed.id}: failed action has no observable follow-up decision`
+			});
+			continue;
+		}
+		decisions.push(failureRecoveryDecision(failed, next, options));
+	}
+	if (decisions.length === 0) diagnostics.push({
+		runId: options.run.runId,
+		severity: "info",
+		reason: `no belief decision points extracted from ${options.source} entries`
+	});
+	return {
+		decisions,
+		diagnostics
+	};
 }
 function inventoryBeliefDecisionPoints(points) {
-  const byKind = [...groupBy(points, (point) => point.kind).entries()].map(
-    ([kind, bucketPoints]) => bucketFor(kind, bucketPoints, { kind })
-  ).sort(sortBuckets);
-  const byTarget = [...groupBy(points, targetIdOf).entries()].filter((entry) => {
-    return entry[0] !== void 0;
-  }).map(([targetId, bucketPoints]) => bucketFor(targetId, bucketPoints, { targetId })).sort(sortBuckets);
-  const diagnostics = [];
-  if (points.length === 0) diagnostics.push("no decision points available");
-  for (const bucket of byTarget) {
-    if (bucket.withOutcome < bucket.n) {
-      diagnostics.push(`${bucket.id}: ${bucket.n - bucket.withOutcome} decision(s) missing outcome`);
-    }
-    if (bucket.withBehaviorProb < bucket.n || bucket.withTargetProb < bucket.n) {
-      diagnostics.push(`${bucket.id}: OPE support incomplete`);
-    }
-  }
-  return { n: points.length, byKind, byTarget, diagnostics };
+	const byKind = [...groupBy(points, (point) => point.kind).entries()].map(([kind, bucketPoints]) => bucketFor(kind, bucketPoints, { kind })).sort(sortBuckets);
+	const byTarget = [...groupBy(points, targetIdOf).entries()].filter((entry) => {
+		return entry[0] !== void 0;
+	}).map(([targetId, bucketPoints]) => bucketFor(targetId, bucketPoints, { targetId })).sort(sortBuckets);
+	const diagnostics = [];
+	if (points.length === 0) diagnostics.push("no decision points available");
+	for (const bucket of byTarget) {
+		if (bucket.withOutcome < bucket.n) diagnostics.push(`${bucket.id}: ${bucket.n - bucket.withOutcome} decision(s) missing outcome`);
+		if (bucket.withBehaviorProb < bucket.n || bucket.withTargetProb < bucket.n) diagnostics.push(`${bucket.id}: OPE support incomplete`);
+	}
+	return {
+		n: points.length,
+		byKind,
+		byTarget,
+		diagnostics
+	};
 }
 function selectBeliefDecisionTarget(points, options = {}) {
-  const minN = options.minN ?? 10;
-  const minOutcomeCoverage = options.minOutcomeCoverage ?? 0.8;
-  const preferredTargets = options.preferredTargets ?? [
-    "failure-recovery",
-    "tool-selection",
-    "graph-completion"
-  ];
-  const inventory = inventoryBeliefDecisionPoints(points);
-  for (const targetId of preferredTargets) {
-    const support = inventory.byTarget.find((bucket) => bucket.targetId === targetId);
-    if (!support) continue;
-    const reasons = [];
-    if (support.n < minN) reasons.push(`need at least ${minN} decisions, got ${support.n}`);
-    const outcomeCoverage = support.n > 0 ? support.withOutcome / support.n : 0;
-    if (outcomeCoverage < minOutcomeCoverage) {
-      reasons.push(
-        `outcome coverage ${outcomeCoverage.toFixed(2)} below ${minOutcomeCoverage.toFixed(2)}`
-      );
-    }
-    if (reasons.length > 0) continue;
-    const targetPoints = points.filter((point) => targetIdOf(point) === targetId);
-    return {
-      id: targetId,
-      label: TARGET_LABELS[targetId],
-      points: targetPoints,
-      support,
-      reasons
-    };
-  }
-  return null;
+	const minN = options.minN ?? 10;
+	const minOutcomeCoverage = options.minOutcomeCoverage ?? .8;
+	const preferredTargets = options.preferredTargets ?? [
+		"failure-recovery",
+		"tool-selection",
+		"graph-completion"
+	];
+	const inventory = inventoryBeliefDecisionPoints(points);
+	for (const targetId of preferredTargets) {
+		const support = inventory.byTarget.find((bucket) => bucket.targetId === targetId);
+		if (!support) continue;
+		const reasons = [];
+		if (support.n < minN) reasons.push(`need at least ${minN} decisions, got ${support.n}`);
+		const outcomeCoverage = support.n > 0 ? support.withOutcome / support.n : 0;
+		if (outcomeCoverage < minOutcomeCoverage) reasons.push(`outcome coverage ${outcomeCoverage.toFixed(2)} below ${minOutcomeCoverage.toFixed(2)}`);
+		if (reasons.length > 0) continue;
+		const targetPoints = points.filter((point) => targetIdOf(point) === targetId);
+		return {
+			id: targetId,
+			label: TARGET_LABELS[targetId],
+			points: targetPoints,
+			support,
+			reasons
+		};
+	}
+	return null;
 }
 function analyzeBeliefDecisionCorpus(options) {
-  const inventory = inventoryBeliefDecisionPoints(options.points);
-  const diagnostics = [...inventory.diagnostics];
-  const target = options.targetId !== void 0 ? targetSelectionFor(options.points, options.targetId, options) : selectBeliefDecisionTarget(options.points, options);
-  if (!target) {
-    diagnostics.push("no decision target has enough support for policy evaluation");
-    return { inventory, diagnostics };
-  }
-  const policy = options.policy ?? thresholdSelectivePolicy({
-    id: `${target.id}:confidence>=${options.confidenceThreshold ?? 0.5}`,
-    confidenceThreshold: options.confidenceThreshold ?? 0.5,
-    belowThresholdAction: "verify"
-  });
-  const minN = options.minN ?? 10;
-  const evaluation = analyzeBeliefPolicy({
-    points: target.points,
-    policy,
-    selective: {
-      minN,
-      minAccepted: options.minAccepted ?? Math.min(5, minN),
-      minUtilityDelta: 0,
-      ...options.policyOptions?.selective ?? {}
-    },
-    calibration: {
-      minPairs: Math.min(10, minN),
-      policy,
-      region: "all",
-      ...options.policyOptions?.calibration ?? {}
-    },
-    ope: {
-      targetPolicy: embeddedBeliefOpeTargetPolicy(`${target.id}:embedded-target-prob`),
-      minEffectiveSampleSize: minN,
-      ...options.policyOptions?.ope ?? {}
-    },
-    requireOpe: options.requireOpe ?? true
-  });
-  return { inventory, target, policy, evaluation, diagnostics };
+	const inventory = inventoryBeliefDecisionPoints(options.points);
+	const diagnostics = [...inventory.diagnostics];
+	const target = options.targetId !== void 0 ? targetSelectionFor(options.points, options.targetId, options) : selectBeliefDecisionTarget(options.points, options);
+	if (!target) {
+		diagnostics.push("no decision target has enough support for policy evaluation");
+		return {
+			inventory,
+			diagnostics
+		};
+	}
+	const policy = options.policy ?? thresholdSelectivePolicy({
+		id: `${target.id}:confidence>=${options.confidenceThreshold ?? .5}`,
+		confidenceThreshold: options.confidenceThreshold ?? .5,
+		belowThresholdAction: "verify"
+	});
+	const minN = options.minN ?? 10;
+	return {
+		inventory,
+		target,
+		policy,
+		evaluation: analyzeBeliefPolicy({
+			points: target.points,
+			policy,
+			selective: {
+				minN,
+				minAccepted: options.minAccepted ?? Math.min(5, minN),
+				minUtilityDelta: 0,
+				...options.policyOptions?.selective ?? {}
+			},
+			calibration: {
+				minPairs: Math.min(10, minN),
+				policy,
+				region: "all",
+				...options.policyOptions?.calibration ?? {}
+			},
+			ope: {
+				targetPolicy: embeddedBeliefOpeTargetPolicy(`${target.id}:embedded-target-prob`),
+				minEffectiveSampleSize: minN,
+				...options.policyOptions?.ope ?? {}
+			},
+			requireOpe: options.requireOpe ?? true
+		}),
+		diagnostics
+	};
 }
 function observedActionsFor(source, entries, options) {
-  const observation = options.observation ?? observeCodeAgentSession({ source, entries, sourcePath: options.sourcePath });
-  if (observation.source !== source) {
-    throw new Error("code-agent observation source does not match extraction source");
-  }
-  return observation.actions.map((action) => observedActionFromSession(action, options));
+	const observation = options.observation ?? observeCodeAgentSession({
+		source,
+		entries,
+		sourcePath: options.sourcePath
+	});
+	if (observation.source !== source) throw new Error("code-agent observation source does not match extraction source");
+	return observation.actions.map((action) => observedActionFromSession(action, options));
 }
 function observedActionFromSession(action, options) {
-  return observedAction({
-    options,
-    localId: action.id,
-    stepIndex: action.stepIndex,
-    kind: action.kind,
-    action: action.name,
-    timestamp: action.timestampMs,
-    success: action.status === "completed" ? true : action.status === "failed" ? false : void 0,
-    costUsd: action.costUsd,
-    metadata: { surface: action.surface, status: action.status, ...action.metadata }
-  });
+	return observedAction({
+		options,
+		localId: action.id,
+		stepIndex: action.stepIndex,
+		kind: action.kind,
+		action: action.name,
+		timestamp: action.timestampMs,
+		success: action.status === "completed" ? true : action.status === "failed" ? false : void 0,
+		costUsd: action.costUsd,
+		metadata: {
+			surface: action.surface,
+			status: action.status,
+			...action.metadata
+		}
+	});
 }
 function toolSelectionDecision(action, options) {
-  return {
-    id: `${options.run.runId}:tool-selection:${action.localId}`,
-    runId: options.run.runId,
-    scenarioId: options.run.scenarioId,
-    stepIndex: action.stepIndex,
-    kind: "tool-select",
-    chosenAction: action.action,
-    candidateActions: [action.action],
-    confidence: 0.65,
-    costUsd: action.costUsd,
-    evidence: action.evidence,
-    outcome: outcomeFromAction(action, options.run),
-    metadata: {
-      target: "tool-selection",
-      source: options.source,
-      actionKind: action.kind,
-      confidenceSource: "fixed-observed-action-prior",
-      ...action.metadata
-    }
-  };
+	return {
+		id: `${options.run.runId}:tool-selection:${action.localId}`,
+		runId: options.run.runId,
+		scenarioId: options.run.scenarioId,
+		stepIndex: action.stepIndex,
+		kind: "tool-select",
+		chosenAction: action.action,
+		candidateActions: [action.action],
+		confidence: .65,
+		costUsd: action.costUsd,
+		evidence: action.evidence,
+		outcome: outcomeFromAction(action, options.run),
+		metadata: {
+			target: "tool-selection",
+			source: options.source,
+			actionKind: action.kind,
+			confidenceSource: "fixed-observed-action-prior",
+			...action.metadata
+		}
+	};
 }
 function graphCompletionDecision(action, options) {
-  return {
-    id: `${options.run.runId}:graph-completion:${action.localId}`,
-    runId: options.run.runId,
-    scenarioId: options.run.scenarioId,
-    stepIndex: action.stepIndex,
-    kind: "stop",
-    chosenAction: "complete",
-    candidateActions: ["complete", "continue", "verify"],
-    confidence: 0.75,
-    evidence: action.evidence,
-    outcome: outcomeFromAction(action, options.run),
-    metadata: {
-      target: "graph-completion",
-      source: options.source,
-      confidenceSource: "fixed-graph-completion-prior",
-      ...action.metadata
-    }
-  };
+	return {
+		id: `${options.run.runId}:graph-completion:${action.localId}`,
+		runId: options.run.runId,
+		scenarioId: options.run.scenarioId,
+		stepIndex: action.stepIndex,
+		kind: "stop",
+		chosenAction: "complete",
+		candidateActions: [
+			"complete",
+			"continue",
+			"verify"
+		],
+		confidence: .75,
+		evidence: action.evidence,
+		outcome: outcomeFromAction(action, options.run),
+		metadata: {
+			target: "graph-completion",
+			source: options.source,
+			confidenceSource: "fixed-graph-completion-prior",
+			...action.metadata
+		}
+	};
 }
 function failureRecoveryDecision(failed, next, options) {
-  const chosenAction = classifyFailureRecovery(failed, next);
-  return {
-    id: `${options.run.runId}:failure-recovery:${failed.localId}`,
-    runId: options.run.runId,
-    scenarioId: options.run.scenarioId,
-    stepIndex: failed.stepIndex,
-    kind: "retry",
-    chosenAction,
-    candidateActions: [...FAILURE_RECOVERY_ACTIONS],
-    confidence: recoveryConfidence(chosenAction),
-    evidence: [...failed.evidence, ...next.evidence],
-    outcome: outcomeFromAction(next, options.run),
-    metadata: {
-      target: "failure-recovery",
-      source: options.source,
-      failedActionKind: failed.kind,
-      failedAction: failed.action,
-      nextActionKind: next.kind,
-      nextAction: next.action,
-      confidenceSource: "heuristic-observed-follow-up"
-    }
-  };
+	const chosenAction = classifyFailureRecovery(failed, next);
+	return {
+		id: `${options.run.runId}:failure-recovery:${failed.localId}`,
+		runId: options.run.runId,
+		scenarioId: options.run.scenarioId,
+		stepIndex: failed.stepIndex,
+		kind: "retry",
+		chosenAction,
+		candidateActions: [...FAILURE_RECOVERY_ACTIONS],
+		confidence: recoveryConfidence(chosenAction),
+		evidence: [...failed.evidence, ...next.evidence],
+		outcome: outcomeFromAction(next, options.run),
+		metadata: {
+			target: "failure-recovery",
+			source: options.source,
+			failedActionKind: failed.kind,
+			failedAction: failed.action,
+			nextActionKind: next.kind,
+			nextAction: next.action,
+			confidenceSource: "heuristic-observed-follow-up"
+		}
+	};
 }
 function classifyFailureRecovery(failed, next) {
-  if (next.kind === "terminal") return "stop";
-  if (isVerificationAction(next.action)) return "verify";
-  if (next.kind === failed.kind && next.action === failed.action) return "retry";
-  return "continue";
+	if (next.kind === "terminal") return "stop";
+	if (isVerificationAction(next.action)) return "verify";
+	if (next.kind === failed.kind && next.action === failed.action) return "retry";
+	return "continue";
 }
 function recoveryConfidence(action) {
-  if (action === "verify") return 0.8;
-  if (action === "retry") return 0.6;
-  if (action === "stop") return 0.55;
-  return 0.35;
+	if (action === "verify") return .8;
+	if (action === "retry") return .6;
+	if (action === "stop") return .55;
+	return .35;
 }
 function isVerificationAction(action) {
-  const normalized = action.toLowerCase();
-  return normalized.includes("verify") || normalized.includes("test") || normalized.includes("check") || normalized.includes("lint") || normalized.includes("build") || normalized.includes("typecheck") || normalized.includes("pytest") || normalized.includes("vitest") || normalized.includes("tsc");
+	const normalized = action.toLowerCase();
+	return normalized.includes("verify") || normalized.includes("test") || normalized.includes("check") || normalized.includes("lint") || normalized.includes("build") || normalized.includes("typecheck") || normalized.includes("pytest") || normalized.includes("vitest") || normalized.includes("tsc");
 }
 function outcomeFromAction(action, run) {
-  const runScore = scoreFromRun(run);
-  const success = action.success ?? (runScore !== null ? runScore >= 0.5 : void 0);
-  const score = action.success === void 0 ? runScore ?? void 0 : action.success ? 1 : 0;
-  if (success === void 0 && score === void 0) return void 0;
-  return {
-    ...success !== void 0 ? { success } : {},
-    ...score !== void 0 ? { score, reward: score } : {},
-    ...action.costUsd !== void 0 ? { costUsd: action.costUsd } : {},
-    metadata: {
-      outcomeSource: action.success === void 0 ? "run-score" : "observed-action-status"
-    }
-  };
+	const runScore = scoreFromRun(run);
+	const success = action.success ?? (runScore !== null ? runScore >= .5 : void 0);
+	const score = action.success === void 0 ? runScore ?? void 0 : action.success ? 1 : 0;
+	if (success === void 0 && score === void 0) return void 0;
+	return {
+		...success !== void 0 ? { success } : {},
+		...score !== void 0 ? {
+			score,
+			reward: score
+		} : {},
+		...action.costUsd !== void 0 ? { costUsd: action.costUsd } : {},
+		metadata: { outcomeSource: action.success === void 0 ? "run-score" : "observed-action-status" }
+	};
 }
 function observedAction(input) {
-  const id = `${input.options.run.runId}:${input.options.source}:${input.localId}`;
-  return {
-    id,
-    localId: input.localId,
-    stepIndex: input.stepIndex,
-    kind: input.kind,
-    action: input.action,
-    timestamp: input.timestamp,
-    success: input.success,
-    costUsd: input.costUsd,
-    evidence: [
-      {
-        source: "event",
-        id,
-        runId: input.options.run.runId,
-        detail: input.action,
-        metadata: {
-          source: input.options.source,
-          sourcePath: input.options.sourcePath,
-          ...input.metadata
-        }
-      }
-    ],
-    metadata: input.metadata ?? {}
-  };
+	const id = `${input.options.run.runId}:${input.options.source}:${input.localId}`;
+	return {
+		id,
+		localId: input.localId,
+		stepIndex: input.stepIndex,
+		kind: input.kind,
+		action: input.action,
+		timestamp: input.timestamp,
+		success: input.success,
+		costUsd: input.costUsd,
+		evidence: [{
+			source: "event",
+			id,
+			runId: input.options.run.runId,
+			detail: input.action,
+			metadata: {
+				source: input.options.source,
+				sourcePath: input.options.sourcePath,
+				...input.metadata
+			}
+		}],
+		metadata: input.metadata ?? {}
+	};
 }
 function targetSelectionFor(points, targetId, options) {
-  const targetPoints = points.filter((point) => targetIdOf(point) === targetId);
-  if (targetPoints.length === 0) return null;
-  const support = bucketFor(targetId, targetPoints, { targetId });
-  const minN = options.minN ?? 10;
-  const minOutcomeCoverage = options.minOutcomeCoverage ?? 0.8;
-  const reasons = [];
-  if (support.n < minN) reasons.push(`need at least ${minN} decisions, got ${support.n}`);
-  const outcomeCoverage = support.n > 0 ? support.withOutcome / support.n : 0;
-  if (outcomeCoverage < minOutcomeCoverage) {
-    reasons.push(
-      `outcome coverage ${outcomeCoverage.toFixed(2)} below ${minOutcomeCoverage.toFixed(2)}`
-    );
-  }
-  if (reasons.length > 0) return null;
-  return { id: targetId, label: TARGET_LABELS[targetId], points: targetPoints, support, reasons };
+	const targetPoints = points.filter((point) => targetIdOf(point) === targetId);
+	if (targetPoints.length === 0) return null;
+	const support = bucketFor(targetId, targetPoints, { targetId });
+	const minN = options.minN ?? 10;
+	const minOutcomeCoverage = options.minOutcomeCoverage ?? .8;
+	const reasons = [];
+	if (support.n < minN) reasons.push(`need at least ${minN} decisions, got ${support.n}`);
+	const outcomeCoverage = support.n > 0 ? support.withOutcome / support.n : 0;
+	if (outcomeCoverage < minOutcomeCoverage) reasons.push(`outcome coverage ${outcomeCoverage.toFixed(2)} below ${minOutcomeCoverage.toFixed(2)}`);
+	if (reasons.length > 0) return null;
+	return {
+		id: targetId,
+		label: TARGET_LABELS[targetId],
+		points: targetPoints,
+		support,
+		reasons
+	};
 }
 function bucketFor(id, points, identity) {
-  const outcomes = points.filter((point) => point.outcome);
-  const scores = outcomes.map((point) => outcomeScore2(point.outcome)).filter((score) => score !== null);
-  const confidences = points.map((point) => point.confidence).filter((confidence) => typeof confidence === "number");
-  const successes = outcomes.filter((point) => point.outcome?.success === true).length;
-  const successDenominator = outcomes.filter(
-    (point) => typeof point.outcome?.success === "boolean"
-  ).length;
-  return {
-    id,
-    ...identity,
-    n: points.length,
-    withOutcome: outcomes.length,
-    withConfidence: confidences.length,
-    withCandidateActions: points.filter((point) => (point.candidateActions?.length ?? 0) > 0).length,
-    withBehaviorProb: points.filter((point) => point.behaviorProb !== void 0).length,
-    withTargetProb: points.filter((point) => point.targetProb !== void 0).length,
-    successRate: successDenominator > 0 ? successes / successDenominator : null,
-    meanScore: scores.length > 0 ? mean2(scores) : null,
-    meanConfidence: confidences.length > 0 ? mean2(confidences) : null
-  };
+	const outcomes = points.filter((point) => point.outcome);
+	const scores = outcomes.map((point) => outcomeScore(point.outcome)).filter((score) => score !== null);
+	const confidences = points.map((point) => point.confidence).filter((confidence) => typeof confidence === "number");
+	const successes = outcomes.filter((point) => point.outcome?.success === true).length;
+	const successDenominator = outcomes.filter((point) => typeof point.outcome?.success === "boolean").length;
+	return {
+		id,
+		...identity,
+		n: points.length,
+		withOutcome: outcomes.length,
+		withConfidence: confidences.length,
+		withCandidateActions: points.filter((point) => (point.candidateActions?.length ?? 0) > 0).length,
+		withBehaviorProb: points.filter((point) => point.behaviorProb !== void 0).length,
+		withTargetProb: points.filter((point) => point.targetProb !== void 0).length,
+		successRate: successDenominator > 0 ? successes / successDenominator : null,
+		meanScore: scores.length > 0 ? mean$1(scores) : null,
+		meanConfidence: confidences.length > 0 ? mean$1(confidences) : null
+	};
 }
 function targetIdOf(point) {
-  const target = point.metadata?.target;
-  if (target === "failure-recovery" || target === "tool-selection" || target === "graph-completion")
-    return target;
-  return void 0;
-}
-function outcomeScore2(outcome) {
-  if (!outcome) return null;
-  if (typeof outcome.score === "number") return outcome.score;
-  if (typeof outcome.reward === "number") return outcome.reward;
-  if (outcome.success === true) return 1;
-  if (outcome.success === false) return 0;
-  return null;
-}
+	const target = point.metadata?.target;
+	if (target === "failure-recovery" || target === "tool-selection" || target === "graph-completion") return target;
+}
+function outcomeScore(outcome) {
+	if (!outcome) return null;
+	if (typeof outcome.score === "number") return outcome.score;
+	if (typeof outcome.reward === "number") return outcome.reward;
+	if (outcome.success === true) return 1;
+	if (outcome.success === false) return 0;
+	return null;
+}
+/**
+* GATED (`trainingScore`). The number this returns becomes a belief-decision
+* point's `outcome.score` AND its `outcome.reward` — corpus labels, i.e.
+* training data by another name. A run flagged as gamed would otherwise label
+* every decision on its trajectory a success and teach a belief model to
+* predict that the gaming path works.
+*/
 function scoreFromRun(run) {
-  if (typeof run.outcome.holdoutScore === "number") return run.outcome.holdoutScore;
-  if (typeof run.outcome.searchScore === "number") return run.outcome.searchScore;
-  return null;
+	return trainingScore(run) ?? null;
 }
 function sortBuckets(a, b) {
-  return b.n - a.n || a.id.localeCompare(b.id);
+	return b.n - a.n || a.id.localeCompare(b.id);
 }
 function groupBy(values, keyOf) {
-  const map = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const key = keyOf(value);
-    const bucket = map.get(key);
-    if (bucket) bucket.push(value);
-    else map.set(key, [value]);
-  }
-  return map;
-}
-function mean2(values) {
-  return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-// src/belief-state/research-evidence.ts
+	const map = /* @__PURE__ */ new Map();
+	for (const value of values) {
+		const key = keyOf(value);
+		const bucket = map.get(key);
+		if (bucket) bucket.push(value);
+		else map.set(key, [value]);
+	}
+	return map;
+}
+function mean$1(values) {
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function isRecord$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/belief-state/research-evidence.ts
 function buildBeliefDecisionResearchEvidencePacket(options) {
-  const claimScope = options.claimScope ?? "counterfactual";
-  const requireOpe = claimScope === "counterfactual";
-  const analysis = analyzeBeliefDecisionCorpus({
-    ...options,
-    requireOpe: options.requireOpe ?? requireOpe
-  });
-  const gates = [
-    corpusGate(analysis),
-    selectiveGate(analysis),
-    calibrationGate(analysis),
-    ...requireOpe ? [opeGate(analysis)] : []
-  ];
-  const caveats = unique([
-    ...gates.flatMap((gate) => gate.caveats),
-    ...claimScope === "selective" ? ["counterfactual claims excluded: OPE support was not required"] : []
-  ]);
-  return {
-    claimScope,
-    status: gates.every((gate) => gate.status === "supported") ? "supported" : "blocked",
-    analysis,
-    gates,
-    blockers: unique(gates.flatMap((gate) => gate.blockers)),
-    caveats
-  };
+	const claimScope = options.claimScope ?? "counterfactual";
+	const requireOpe = claimScope === "counterfactual";
+	const analysis = analyzeBeliefDecisionCorpus({
+		...options,
+		requireOpe: options.requireOpe ?? requireOpe
+	});
+	const gates = [
+		corpusGate(analysis),
+		selectiveGate(analysis),
+		calibrationGate(analysis),
+		...requireOpe ? [opeGate(analysis)] : []
+	];
+	const caveats = unique([...gates.flatMap((gate) => gate.caveats), ...claimScope === "selective" ? ["counterfactual claims excluded: OPE support was not required"] : []]);
+	return {
+		claimScope,
+		status: gates.every((gate) => gate.status === "supported") ? "supported" : "blocked",
+		analysis,
+		gates,
+		blockers: unique(gates.flatMap((gate) => gate.blockers)),
+		caveats
+	};
 }
 function corpusGate(analysis) {
-  const support = analysis.target?.support;
-  if (!support) {
-    return blocked("corpus", "no decision target has enough outcome support");
-  }
-  const caveats = support.withBehaviorProb < support.n || support.withTargetProb < support.n ? ["propensity support incomplete; counterfactual claims will require OPE support"] : [];
-  return { id: "corpus", status: "supported", blockers: [], caveats };
+	const support = analysis.target?.support;
+	if (!support) return blocked("corpus", "no decision target has enough outcome support");
+	return {
+		id: "corpus",
+		status: "supported",
+		blockers: [],
+		caveats: support.withBehaviorProb < support.n || support.withTargetProb < support.n ? ["propensity support incomplete; counterfactual claims will require OPE support"] : []
+	};
 }
 function selectiveGate(analysis) {
-  const evaluation = analysis.evaluation;
-  if (!evaluation) return blocked("selective", "no policy evaluation was produced");
-  if (evaluation.selectiveStatus !== "ship") {
-    return blocked(
-      "selective",
-      ...orDefault(
-        evaluation.selective.reasons,
-        `selective status is ${evaluation.selectiveStatus}`
-      )
-    );
-  }
-  return { id: "selective", status: "supported", blockers: [], caveats: [] };
+	const evaluation = analysis.evaluation;
+	if (!evaluation) return blocked("selective", "no policy evaluation was produced");
+	if (evaluation.selectiveStatus !== "ship") return blocked("selective", ...orDefault(evaluation.selective.reasons, `selective status is ${evaluation.selectiveStatus}`));
+	return {
+		id: "selective",
+		status: "supported",
+		blockers: [],
+		caveats: []
+	};
 }
 function calibrationGate(analysis) {
-  const evaluation = analysis.evaluation;
-  if (!evaluation) return blocked("calibration", "no policy evaluation was produced");
-  if (evaluation.calibrationStatus !== "supported") {
-    return blocked("calibration", "not enough confidence/outcome pairs for calibration");
-  }
-  return { id: "calibration", status: "supported", blockers: [], caveats: [] };
+	const evaluation = analysis.evaluation;
+	if (!evaluation) return blocked("calibration", "no policy evaluation was produced");
+	if (evaluation.calibrationStatus !== "supported") return blocked("calibration", "not enough confidence/outcome pairs for calibration");
+	return {
+		id: "calibration",
+		status: "supported",
+		blockers: [],
+		caveats: []
+	};
 }
 function opeGate(analysis) {
-  const evaluation = analysis.evaluation;
-  if (!evaluation) return blocked("ope", "no policy evaluation was produced");
-  if (evaluation.opeStatus !== "supported") {
-    const reasons = evaluation.ope?.support.reasons ?? evaluation.diagnostics.filter((diagnostic) => diagnostic.includes("OPE"));
-    return blocked("ope", ...orDefault(reasons, "missing OPE support"));
-  }
-  return { id: "ope", status: "supported", blockers: [], caveats: [] };
+	const evaluation = analysis.evaluation;
+	if (!evaluation) return blocked("ope", "no policy evaluation was produced");
+	if (evaluation.opeStatus !== "supported") return blocked("ope", ...orDefault(evaluation.ope?.support.reasons ?? evaluation.diagnostics.filter((diagnostic) => diagnostic.includes("OPE")), "missing OPE support"));
+	return {
+		id: "ope",
+		status: "supported",
+		blockers: [],
+		caveats: []
+	};
 }
 function blocked(id, ...blockers) {
-  return { id, status: "blocked", blockers, caveats: [] };
+	return {
+		id,
+		status: "blocked",
+		blockers,
+		caveats: []
+	};
 }
 function orDefault(values, fallback) {
-  return values.length > 0 ? values : [fallback];
+	return values.length > 0 ? values : [fallback];
 }
 function unique(values) {
-  return [...new Set(values)];
+	return [...new Set(values)];
 }
-
-// src/belief-state/code-agent-evidence.ts
+//#endregion
+//#region src/belief-state/code-agent-evidence.ts
 function buildCodeAgentBeliefEvidenceCorpus(options) {
-  const { sessions, ...evidenceOptions } = options;
-  const runs = [];
-  const metrics = [];
-  const intakeDiagnostics = [];
-  const extractionDiagnostics = [];
-  const decisions = [];
-  for (const session of sessions) {
-    const intake = fromCodeAgentBeliefSession(session);
-    runs.push(...intake.runs);
-    metrics.push(...intake.metrics);
-    intakeDiagnostics.push(...intake.diagnostics);
-    for (const [index, run] of intake.runs.entries()) {
-      const extraction = extractCodeAgentBeliefDecisionPoints({
-        source: session.source,
-        entries: session.entries,
-        observation: intake.observations[index],
-        run,
-        sourcePath: session.sourcePath
-      });
-      decisions.push(...extraction.decisions);
-      extractionDiagnostics.push(...extraction.diagnostics);
-    }
-  }
-  const evidence = buildBeliefDecisionResearchEvidencePacket({
-    ...evidenceOptions,
-    points: decisions
-  });
-  return {
-    runs,
-    metrics,
-    intakeDiagnostics,
-    extractionDiagnostics,
-    decisions,
-    inventory: inventoryBeliefDecisionPoints(decisions),
-    evidence
-  };
+	const { sessions, ...evidenceOptions } = options;
+	const runs = [];
+	const metrics = [];
+	const intakeDiagnostics = [];
+	const extractionDiagnostics = [];
+	const decisions = [];
+	for (const session of sessions) {
+		const intake = fromCodeAgentBeliefSession(session);
+		runs.push(...intake.runs);
+		metrics.push(...intake.metrics);
+		intakeDiagnostics.push(...intake.diagnostics);
+		for (const [index, run] of intake.runs.entries()) {
+			const extraction = extractCodeAgentBeliefDecisionPoints({
+				source: session.source,
+				entries: session.entries,
+				observation: intake.observations[index],
+				run,
+				sourcePath: session.sourcePath
+			});
+			decisions.push(...extraction.decisions);
+			extractionDiagnostics.push(...extraction.diagnostics);
+		}
+	}
+	const evidence = buildBeliefDecisionResearchEvidencePacket({
+		...evidenceOptions,
+		points: decisions
+	});
+	return {
+		runs,
+		metrics,
+		intakeDiagnostics,
+		extractionDiagnostics,
+		decisions,
+		inventory: inventoryBeliefDecisionPoints(decisions),
+		evidence
+	};
 }
 function fromCodeAgentBeliefSession(session) {
-  switch (session.source) {
-    case "codex":
-      return fromCodexSession(session);
-    case "claude-code":
-      return fromClaudeCodeSession(session);
-    case "opencode":
-      return fromOpenCodeSession(session);
-    case "kimi-code":
-      return fromKimiCodeSession(session);
-    case "pi":
-      return fromPiSession(session);
-  }
-}
-
-// src/belief-state/types.ts
-var BELIEF_DECISION_KINDS = [
-  "continue",
-  "verify",
-  "ask",
-  "retry",
-  "stop",
-  "memory-write",
-  "memory-read",
-  "tool-select",
-  "skill-select",
-  "workflow-select",
-  "surface-promote"
+	switch (session.source) {
+		case "codex": return fromCodexSession(session);
+		case "claude-code": return fromClaudeCodeSession(session);
+		case "opencode": return fromOpenCodeSession(session);
+		case "kimi-code": return fromKimiCodeSession(session);
+		case "pi": return fromPiSession(session);
+	}
+}
+//#endregion
+//#region src/belief-state/types.ts
+const BELIEF_DECISION_KINDS = [
+	"continue",
+	"verify",
+	"ask",
+	"retry",
+	"stop",
+	"memory-write",
+	"memory-read",
+	"tool-select",
+	"skill-select",
+	"workflow-select",
+	"surface-promote"
 ];
-var BELIEF_EVIDENCE_SOURCES = [
-  "run",
-  "span",
-  "event",
-  "finding",
-  "memory",
-  "knowledge",
-  "policy"
+const BELIEF_EVIDENCE_SOURCES = [
+	"run",
+	"span",
+	"event",
+	"finding",
+	"memory",
+	"knowledge",
+	"policy"
 ];
-var BELIEF_EVIDENCE_QUALITIES = [
-  "direct",
-  "derived",
-  "self-reported",
-  "unverified",
-  "stale",
-  "contradicted"
+const BELIEF_EVIDENCE_QUALITIES = [
+	"direct",
+	"derived",
+	"self-reported",
+	"unverified",
+	"stale",
+	"contradicted"
 ];
-var BELIEF_EVALUATION_CRITERIA = [
-  {
-    id: "capture-integrity",
-    label: "Capture integrity",
-    reasonCodes: ["trace-missing", "run-record-missing", "backend-integrity-missing"]
-  },
-  {
-    id: "decision-completeness",
-    label: "Decision completeness",
-    reasonCodes: [
-      "candidate-actions-missing",
-      "chosen-action-missing",
-      "decision-evidence-missing"
-    ]
-  },
-  {
-    id: "evidence-quality",
-    label: "Evidence quality",
-    reasonCodes: [
-      "evidence-stale",
-      "evidence-contradictory",
-      "evidence-unverified",
-      "evidence-self-reported"
-    ]
-  },
-  {
-    id: "outcome-quality",
-    label: "Outcome quality",
-    reasonCodes: ["outcome-missing", "outcome-delayed", "cost-missing"]
-  },
-  {
-    id: "calibration",
-    label: "Calibration",
-    reasonCodes: ["confidence-missing", "calibration-unsupported", "calibration-gap-high"]
-  },
-  {
-    id: "accepted-region-risk",
-    label: "Accepted-region risk",
-    reasonCodes: ["accepted-error-high", "coverage-too-low"]
-  },
-  {
-    id: "policy-value",
-    label: "Policy value",
-    reasonCodes: ["utility-lift-missing", "baseline-dominates", "cost-too-high"]
-  },
-  {
-    id: "ope-support",
-    label: "OPE support",
-    reasonCodes: [
-      "behavior-propensity-missing",
-      "behavior-propensity-invalid",
-      "target-propensity-missing",
-      "target-propensity-invalid",
-      "effective-sample-size-low",
-      "importance-weight-high"
-    ]
-  },
-  {
-    id: "memory-health",
-    label: "Memory health",
-    reasonCodes: [
-      "memory-stale",
-      "memory-poisoning-risk",
-      "context-bloat",
-      "memory-write-unverified"
-    ]
-  },
-  {
-    id: "surface-attribution",
-    label: "Surface attribution",
-    reasonCodes: ["surface-claim-unsupported", "causal-attribution-missing"]
-  },
-  {
-    id: "generalization",
-    label: "Generalization",
-    reasonCodes: [
-      "split-missing",
-      "holdout-regression",
-      "task-family-coverage-low",
-      "leakage-risk"
-    ]
-  },
-  {
-    id: "promotion",
-    label: "Promotion",
-    reasonCodes: ["negative-control-failed", "promotion-gate-failed", "human-review-required"]
-  }
+const BELIEF_EVALUATION_CRITERIA = [
+	{
+		id: "capture-integrity",
+		label: "Capture integrity",
+		reasonCodes: [
+			"trace-missing",
+			"run-record-missing",
+			"backend-integrity-missing"
+		]
+	},
+	{
+		id: "decision-completeness",
+		label: "Decision completeness",
+		reasonCodes: [
+			"candidate-actions-missing",
+			"chosen-action-missing",
+			"decision-evidence-missing"
+		]
+	},
+	{
+		id: "evidence-quality",
+		label: "Evidence quality",
+		reasonCodes: [
+			"evidence-stale",
+			"evidence-contradictory",
+			"evidence-unverified",
+			"evidence-self-reported"
+		]
+	},
+	{
+		id: "outcome-quality",
+		label: "Outcome quality",
+		reasonCodes: [
+			"outcome-missing",
+			"outcome-delayed",
+			"cost-missing"
+		]
+	},
+	{
+		id: "calibration",
+		label: "Calibration",
+		reasonCodes: [
+			"confidence-missing",
+			"calibration-unsupported",
+			"calibration-gap-high"
+		]
+	},
+	{
+		id: "accepted-region-risk",
+		label: "Accepted-region risk",
+		reasonCodes: ["accepted-error-high", "coverage-too-low"]
+	},
+	{
+		id: "policy-value",
+		label: "Policy value",
+		reasonCodes: [
+			"utility-lift-missing",
+			"baseline-dominates",
+			"cost-too-high"
+		]
+	},
+	{
+		id: "ope-support",
+		label: "OPE support",
+		reasonCodes: [
+			"behavior-propensity-missing",
+			"behavior-propensity-invalid",
+			"target-propensity-missing",
+			"target-propensity-invalid",
+			"effective-sample-size-low",
+			"importance-weight-high"
+		]
+	},
+	{
+		id: "memory-health",
+		label: "Memory health",
+		reasonCodes: [
+			"memory-stale",
+			"memory-poisoning-risk",
+			"context-bloat",
+			"memory-write-unverified"
+		]
+	},
+	{
+		id: "surface-attribution",
+		label: "Surface attribution",
+		reasonCodes: ["surface-claim-unsupported", "causal-attribution-missing"]
+	},
+	{
+		id: "generalization",
+		label: "Generalization",
+		reasonCodes: [
+			"split-missing",
+			"holdout-regression",
+			"task-family-coverage-low",
+			"leakage-risk"
+		]
+	},
+	{
+		id: "promotion",
+		label: "Promotion",
+		reasonCodes: [
+			"negative-control-failed",
+			"promotion-gate-failed",
+			"human-review-required"
+		]
+	}
 ];
 function isBeliefDecisionKind(value) {
-  return typeof value === "string" && BELIEF_DECISION_KINDS.includes(value);
+	return typeof value === "string" && BELIEF_DECISION_KINDS.includes(value);
 }
 function isBeliefEvidenceSource(value) {
-  return typeof value === "string" && BELIEF_EVIDENCE_SOURCES.includes(value);
-}
-
-// src/belief-state/extract.ts
-var DECISION_MARKERS = /* @__PURE__ */ new Set(["belief_decision", "belief.decision", "decision_point"]);
+	return typeof value === "string" && BELIEF_EVIDENCE_SOURCES.includes(value);
+}
+//#endregion
+//#region src/belief-state/extract.ts
+const DECISION_MARKERS = /* @__PURE__ */ new Set([
+	"belief_decision",
+	"belief.decision",
+	"decision_point"
+]);
 async function extractBeliefDecisionPoints(store, options = {}) {
-  const runs = options.runIds ? (await Promise.all(options.runIds.map((runId) => store.getRun(runId)))).filter(Boolean) : await store.listRuns();
-  const decisions = [];
-  const diagnostics = [];
-  for (const run of runs) {
-    if (!run) continue;
-    const events = await store.events({ runId: run.runId });
-    const spans = await store.spans({ runId: run.runId });
-    const spanIds = new Set(spans.map((span) => span.spanId));
-    let stepIndex = 0;
-    for (const event of [...events].sort((a, b) => a.timestamp - b.timestamp)) {
-      const parsed = parseDecisionEvent(event, {
-        scenarioId: run.scenarioId,
-        stepIndex,
-        spanExists: event.spanId ? spanIds.has(event.spanId) : false
-      });
-      if (!parsed) continue;
-      if ("diagnostic" in parsed) {
-        diagnostics.push(parsed.diagnostic);
-        continue;
-      }
-      decisions.push(parsed.decision);
-      stepIndex++;
-    }
-  }
-  return { decisions, diagnostics };
+	const runs = options.runIds ? (await Promise.all(options.runIds.map((runId) => store.getRun(runId)))).filter(Boolean) : await store.listRuns();
+	const decisions = [];
+	const diagnostics = [];
+	for (const run of runs) {
+		if (!run) continue;
+		const events = await store.events({ runId: run.runId });
+		const spans = await store.spans({ runId: run.runId });
+		const spanIds = new Set(spans.map((span) => span.spanId));
+		let stepIndex = 0;
+		for (const event of [...events].sort((a, b) => a.timestamp - b.timestamp)) {
+			const parsed = parseDecisionEvent(event, {
+				scenarioId: run.scenarioId,
+				stepIndex,
+				spanExists: event.spanId ? spanIds.has(event.spanId) : false
+			});
+			if (!parsed) continue;
+			if ("diagnostic" in parsed) {
+				diagnostics.push(parsed.diagnostic);
+				continue;
+			}
+			decisions.push(parsed.decision);
+			stepIndex++;
+		}
+	}
+	return {
+		decisions,
+		diagnostics
+	};
 }
 function parseDecisionEvent(event, context) {
-  const payload = event.payload;
-  const marker = stringField(payload, "kind") ?? stringField(payload, "type");
-  if (!marker || !DECISION_MARKERS.has(marker)) return null;
-  const decisionKind = stringField(payload, "decisionKind");
-  if (!isBeliefDecisionKind(decisionKind)) {
-    return {
-      diagnostic: {
-        runId: event.runId,
-        eventId: event.eventId,
-        severity: "warning",
-        reason: `belief decision event has unsupported decisionKind "${decisionKind ?? ""}"`
-      }
-    };
-  }
-  const chosenAction = stringField(payload, "chosenAction");
-  if (!chosenAction) {
-    return {
-      diagnostic: {
-        runId: event.runId,
-        eventId: event.eventId,
-        severity: "warning",
-        reason: "belief decision event is missing chosenAction"
-      }
-    };
-  }
-  const evidence = [
-    {
-      source: "event",
-      id: event.eventId,
-      runId: event.runId,
-      eventId: event.eventId,
-      quality: "direct"
-    }
-  ];
-  if (event.spanId && context.spanExists) {
-    evidence.push({
-      source: "span",
-      id: event.spanId,
-      runId: event.runId,
-      spanId: event.spanId,
-      quality: "direct"
-    });
-  }
-  return {
-    decision: {
-      id: stringField(payload, "id") ?? event.eventId,
-      runId: event.runId,
-      scenarioId: stringField(payload, "scenarioId") ?? context.scenarioId,
-      stepIndex: numberField(payload, "stepIndex") ?? context.stepIndex,
-      kind: decisionKind,
-      chosenAction,
-      candidateActions: stringArrayField(payload, "candidateActions"),
-      confidence: finiteUnitField(payload, "confidence"),
-      behaviorProb: numberField(payload, "behaviorProb"),
-      targetProb: numberField(payload, "targetProb"),
-      qHatChosen: finiteUnitField(payload, "qHatChosen"),
-      vHatTarget: finiteUnitField(payload, "vHatTarget"),
-      qHat: finiteUnitField(payload, "qHat"),
-      costUsd: nonNegativeNumberField(payload, "costUsd"),
-      evidence,
-      outcome: parseOutcome(payload),
-      metadata: recordField(payload, "metadata")
-    }
-  };
+	const payload = event.payload;
+	const marker = stringField(payload, "kind") ?? stringField(payload, "type");
+	if (!marker || !DECISION_MARKERS.has(marker)) return null;
+	const decisionKind = stringField(payload, "decisionKind");
+	if (!isBeliefDecisionKind(decisionKind)) return { diagnostic: {
+		runId: event.runId,
+		eventId: event.eventId,
+		severity: "warning",
+		reason: `belief decision event has unsupported decisionKind "${decisionKind ?? ""}"`
+	} };
+	const chosenAction = stringField(payload, "chosenAction");
+	if (!chosenAction) return { diagnostic: {
+		runId: event.runId,
+		eventId: event.eventId,
+		severity: "warning",
+		reason: "belief decision event is missing chosenAction"
+	} };
+	const evidence = [{
+		source: "event",
+		id: event.eventId,
+		runId: event.runId,
+		eventId: event.eventId,
+		quality: "direct"
+	}];
+	if (event.spanId && context.spanExists) evidence.push({
+		source: "span",
+		id: event.spanId,
+		runId: event.runId,
+		spanId: event.spanId,
+		quality: "direct"
+	});
+	return { decision: {
+		id: stringField(payload, "id") ?? event.eventId,
+		runId: event.runId,
+		scenarioId: stringField(payload, "scenarioId") ?? context.scenarioId,
+		stepIndex: numberField(payload, "stepIndex") ?? context.stepIndex,
+		kind: decisionKind,
+		chosenAction,
+		candidateActions: stringArrayField(payload, "candidateActions"),
+		confidence: finiteUnitField(payload, "confidence"),
+		behaviorProb: numberField(payload, "behaviorProb"),
+		targetProb: numberField(payload, "targetProb"),
+		qHatChosen: finiteUnitField(payload, "qHatChosen"),
+		vHatTarget: finiteUnitField(payload, "vHatTarget"),
+		costUsd: nonNegativeNumberField(payload, "costUsd"),
+		evidence,
+		outcome: parseOutcome(payload),
+		metadata: recordField(payload, "metadata")
+	} };
 }
 function parseOutcome(payload) {
-  const value = recordField(payload, "outcome");
-  if (!value) return void 0;
-  return {
-    success: typeof value.success === "boolean" ? value.success : void 0,
-    score: finiteUnitField(value, "score"),
-    reward: finiteUnitField(value, "reward"),
-    costUsd: nonNegativeNumberField(value, "costUsd"),
-    observedAt: stringField(value, "observedAt"),
-    metadata: recordField(value, "metadata")
-  };
+	const value = recordField(payload, "outcome");
+	if (!value) return void 0;
+	return {
+		success: typeof value.success === "boolean" ? value.success : void 0,
+		score: finiteUnitField(value, "score"),
+		reward: finiteUnitField(value, "reward"),
+		costUsd: nonNegativeNumberField(value, "costUsd"),
+		observedAt: stringField(value, "observedAt"),
+		metadata: recordField(value, "metadata")
+	};
 }
 function stringField(obj, key) {
-  const value = obj[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
+	const value = obj[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function numberField(obj, key) {
-  const value = obj[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+	const value = obj[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function finiteUnitField(obj, key) {
-  const value = numberField(obj, key);
-  return value === void 0 ? void 0 : Math.max(0, Math.min(1, value));
+	const value = numberField(obj, key);
+	return value === void 0 ? void 0 : Math.max(0, Math.min(1, value));
 }
 function nonNegativeNumberField(obj, key) {
-  const value = numberField(obj, key);
-  return value === void 0 ? void 0 : Math.max(0, value);
+	const value = numberField(obj, key);
+	return value === void 0 ? void 0 : Math.max(0, value);
 }
 function stringArrayField(obj, key) {
-  const value = obj[key];
-  if (!Array.isArray(value)) return void 0;
-  const strings = value.filter(
-    (item) => typeof item === "string" && item.length > 0
-  );
-  return strings.length > 0 ? strings : void 0;
+	const value = obj[key];
+	if (!Array.isArray(value)) return void 0;
+	const strings = value.filter((item) => typeof item === "string" && item.length > 0);
+	return strings.length > 0 ? strings : void 0;
 }
 function recordField(obj, key) {
-  const value = obj[key];
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  return value;
-}
-
-// src/belief-state/runtime-hooks.ts
-var DEFAULT_MAX_CONTEXT_CHARS = 12e3;
-var DEFAULT_PAYLOAD_PREVIEW_CHARS = 2e3;
+	const value = obj[key];
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	return value;
+}
+//#endregion
+//#region src/belief-state/runtime-hooks.ts
+const DEFAULT_MAX_CONTEXT_CHARS$1 = 12e3;
+const DEFAULT_PAYLOAD_PREVIEW_CHARS = 2e3;
 function runtimeDecisionPointToBeliefShadowProbeInput(point, options) {
-  const diagnostics = [];
-  const decisionKind = resolveDecisionKind(point, options.decisionKind, diagnostics);
-  if (!decisionKind) return { diagnostics };
-  const lifecycleEvidence = runtimeHookEventsToEvidenceRefs(point, options);
-  const evidence = [...point.evidence ?? [], ...lifecycleEvidence];
-  return {
-    input: {
-      probeId: options.probeId,
-      decisionId: point.id,
-      runId: point.runId,
-      scenarioId: point.scenarioId,
-      stepIndex: point.stepIndex,
-      decisionKind,
-      candidateActions: uniqueStrings(point.candidateActions ?? []),
-      evidence: evidence.map((ref) => ({
-        id: ref.id,
-        source: ref.source,
-        ...options.includeEvidenceDetail && ref.detail ? { detail: ref.detail } : {},
-        ...ref.quality ? { quality: ref.quality } : {}
-      })),
-      context: trimText(point.context, options.maxContextChars),
-      metadata: mergeMetadata(point.metadata, lifecycleMetadata(lifecycleEvidence))
-    },
-    diagnostics
-  };
+	const diagnostics = [];
+	const decisionKind = resolveDecisionKind(point, options.decisionKind, diagnostics);
+	if (!decisionKind) return { diagnostics };
+	const lifecycleEvidence = runtimeHookEventsToEvidenceRefs(point, options);
+	const evidence = [...point.evidence ?? [], ...lifecycleEvidence];
+	return {
+		input: {
+			probeId: options.probeId,
+			decisionId: point.id,
+			runId: point.runId,
+			scenarioId: point.scenarioId,
+			stepIndex: point.stepIndex,
+			decisionKind,
+			candidateActions: uniqueStrings$1(point.candidateActions ?? []),
+			evidence: evidence.map((ref) => ({
+				id: ref.id,
+				source: ref.source,
+				...options.includeEvidenceDetail && ref.detail ? { detail: ref.detail } : {},
+				...ref.quality ? { quality: ref.quality } : {}
+			})),
+			context: trimText$1(point.context, options.maxContextChars),
+			metadata: mergeMetadata(point.metadata, lifecycleMetadata(lifecycleEvidence))
+		},
+		diagnostics
+	};
 }
 function runtimeDecisionPointToBeliefDecisionPoint(point, options) {
-  const diagnostics = [];
-  const decisionKind = resolveDecisionKind(point, options.decisionKind, diagnostics);
-  const chosenAction = stringOrUndefined(options.chosenAction);
-  if (!chosenAction) {
-    diagnostics.push({
-      decisionId: point.id,
-      severity: "error",
-      reason: "missing chosenAction"
-    });
-  }
-  const candidateActions = uniqueStrings(point.candidateActions ?? []);
-  if (chosenAction && candidateActions.length > 0 && !candidateActions.includes(chosenAction)) {
-    diagnostics.push({
-      decisionId: point.id,
-      severity: "warning",
-      reason: `chosenAction ${chosenAction} is not in candidateActions`
-    });
-  }
-  if (!decisionKind || !chosenAction) return { diagnostics };
-  const lifecycleEvidence = runtimeHookEventsToEvidenceRefs(point, options);
-  const evidence = [...point.evidence ?? [], ...lifecycleEvidence];
-  return {
-    point: {
-      id: point.id,
-      runId: point.runId,
-      scenarioId: point.scenarioId,
-      stepIndex: point.stepIndex,
-      kind: decisionKind,
-      chosenAction,
-      candidateActions,
-      confidence: unitProbabilityOrUndefined(options.confidence),
-      behaviorProb: finiteNumberOrUndefined(options.behaviorProb),
-      targetProb: finiteNumberOrUndefined(options.targetProb),
-      qHatChosen: options.qHatChosen === null ? null : unitProbabilityOrUndefined(options.qHatChosen),
-      vHatTarget: options.vHatTarget === null ? null : unitProbabilityOrUndefined(options.vHatTarget),
-      qHat: options.qHat === null ? null : unitProbabilityOrUndefined(options.qHat),
-      costUsd: nonNegativeNumberOrUndefined(options.costUsd),
-      evidence: evidence.map((ref) => runtimeEvidenceToBeliefEvidence(ref, point)),
-      outcome: options.outcome,
-      metadata: mergeMetadata(
-        mergeMetadata(point.metadata, lifecycleMetadata(lifecycleEvidence)),
-        options.metadata
-      )
-    },
-    diagnostics
-  };
+	const diagnostics = [];
+	const decisionKind = resolveDecisionKind(point, options.decisionKind, diagnostics);
+	const chosenAction = stringOrUndefined(options.chosenAction);
+	if (!chosenAction) diagnostics.push({
+		decisionId: point.id,
+		severity: "error",
+		reason: "missing chosenAction"
+	});
+	const candidateActions = uniqueStrings$1(point.candidateActions ?? []);
+	if (chosenAction && candidateActions.length > 0 && !candidateActions.includes(chosenAction)) diagnostics.push({
+		decisionId: point.id,
+		severity: "warning",
+		reason: `chosenAction ${chosenAction} is not in candidateActions`
+	});
+	if (!decisionKind || !chosenAction) return { diagnostics };
+	const lifecycleEvidence = runtimeHookEventsToEvidenceRefs(point, options);
+	const evidence = [...point.evidence ?? [], ...lifecycleEvidence];
+	return {
+		point: {
+			id: point.id,
+			runId: point.runId,
+			scenarioId: point.scenarioId,
+			stepIndex: point.stepIndex,
+			kind: decisionKind,
+			chosenAction,
+			candidateActions,
+			confidence: unitProbabilityOrUndefined(options.confidence),
+			behaviorProb: finiteNumberOrUndefined(options.behaviorProb),
+			targetProb: finiteNumberOrUndefined(options.targetProb),
+			qHatChosen: options.qHatChosen === null ? null : unitProbabilityOrUndefined(options.qHatChosen),
+			vHatTarget: options.vHatTarget === null ? null : unitProbabilityOrUndefined(options.vHatTarget),
+			costUsd: nonNegativeNumberOrUndefined(options.costUsd),
+			evidence: evidence.map((ref) => runtimeEvidenceToBeliefEvidence(ref, point)),
+			outcome: options.outcome,
+			metadata: mergeMetadata(mergeMetadata(point.metadata, lifecycleMetadata(lifecycleEvidence)), options.metadata)
+		},
+		diagnostics
+	};
 }
 function createBeliefRuntimeHookCollector(defaults) {
-  const decisions = [];
-  const events = [];
-  return {
-    hooks: {
-      onEvent: (event) => {
-        events.push(snapshotRuntimeHookEvent(event));
-      },
-      onDecisionPoint: (point) => {
-        decisions.push(snapshotRuntimeDecisionPoint(point));
-      }
-    },
-    decisions,
-    events,
-    toShadowProbeInputs: (options = {}) => {
-      const inputs = [];
-      const diagnostics = [];
-      const includeLifecycleEvidence = options.includeLifecycleEvidence ?? defaults.includeLifecycleEvidence;
-      for (const point of decisions) {
-        const report = runtimeDecisionPointToBeliefShadowProbeInput(point, {
-          ...defaults,
-          ...options,
-          includeLifecycleEvidence,
-          lifecycleEvents: includeLifecycleEvidence === false ? void 0 : options.lifecycleEvents ?? defaults.lifecycleEvents ?? events
-        });
-        if (report.input) inputs.push(report.input);
-        diagnostics.push(...report.diagnostics);
-      }
-      return { inputs, diagnostics };
-    },
-    clear: () => {
-      decisions.length = 0;
-      events.length = 0;
-    }
-  };
+	const decisions = [];
+	const events = [];
+	return {
+		hooks: {
+			onEvent: (event) => {
+				events.push(snapshotRuntimeHookEvent(event));
+			},
+			onDecisionPoint: (point) => {
+				decisions.push(snapshotRuntimeDecisionPoint(point));
+			}
+		},
+		decisions,
+		events,
+		toShadowProbeInputs: (options = {}) => {
+			const inputs = [];
+			const diagnostics = [];
+			const includeLifecycleEvidence = options.includeLifecycleEvidence ?? defaults.includeLifecycleEvidence;
+			for (const point of decisions) {
+				const report = runtimeDecisionPointToBeliefShadowProbeInput(point, {
+					...defaults,
+					...options,
+					includeLifecycleEvidence,
+					lifecycleEvents: includeLifecycleEvidence === false ? void 0 : options.lifecycleEvents ?? defaults.lifecycleEvents ?? events
+				});
+				if (report.input) inputs.push(report.input);
+				diagnostics.push(...report.diagnostics);
+			}
+			return {
+				inputs,
+				diagnostics
+			};
+		},
+		clear: () => {
+			decisions.length = 0;
+			events.length = 0;
+		}
+	};
 }
 function resolveDecisionKind(point, override, diagnostics) {
-  const kind = override ?? point.kind;
-  if (isBeliefDecisionKind(kind)) return kind;
-  diagnostics.push({
-    decisionId: point.id,
-    severity: "error",
-    reason: `unsupported decisionKind "${kind}"`
-  });
-  return void 0;
+	const kind = override ?? point.kind;
+	if (isBeliefDecisionKind(kind)) return kind;
+	diagnostics.push({
+		decisionId: point.id,
+		severity: "error",
+		reason: `unsupported decisionKind "${kind}"`
+	});
 }
 function runtimeEvidenceToBeliefEvidence(ref, point) {
-  if (isBeliefEvidenceSource(ref.source)) {
-    return {
-      source: ref.source,
-      id: ref.id,
-      runId: point.runId,
-      detail: ref.detail,
-      quality: ref.quality,
-      metadata: ref.metadata
-    };
-  }
-  return {
-    source: "event",
-    id: ref.id,
-    runId: point.runId,
-    detail: ref.detail,
-    quality: ref.quality,
-    metadata: mergeMetadata({ runtimeSource: ref.source }, ref.metadata)
-  };
+	if (isBeliefEvidenceSource(ref.source)) return {
+		source: ref.source,
+		id: ref.id,
+		runId: point.runId,
+		detail: ref.detail,
+		quality: ref.quality,
+		metadata: ref.metadata
+	};
+	return {
+		source: "event",
+		id: ref.id,
+		runId: point.runId,
+		detail: ref.detail,
+		quality: ref.quality,
+		metadata: mergeMetadata({ runtimeSource: ref.source }, ref.metadata)
+	};
 }
 function runtimeHookEventsToEvidenceRefs(point, options) {
-  if (options.includeLifecycleEvidence === false) return [];
-  return (options.lifecycleEvents ?? []).filter((event) => runtimeHookEventMatchesDecision(point, event)).map(runtimeHookEventToEvidenceRef);
+	if (options.includeLifecycleEvidence === false) return [];
+	return (options.lifecycleEvents ?? []).filter((event) => runtimeHookEventMatchesDecision(point, event)).map(runtimeHookEventToEvidenceRef);
 }
 function runtimeHookEventMatchesDecision(point, event) {
-  if (event.runId !== point.runId) return false;
-  if (event.scenarioId && point.scenarioId && event.scenarioId !== point.scenarioId) return false;
-  return event.stepIndex === void 0 || event.stepIndex === point.stepIndex;
+	if (event.runId !== point.runId) return false;
+	if (event.scenarioId && point.scenarioId && event.scenarioId !== point.scenarioId) return false;
+	return event.stepIndex === void 0 || event.stepIndex === point.stepIndex;
 }
 function runtimeHookEventToEvidenceRef(event) {
-  return {
-    source: "runtime_event",
-    id: event.id,
-    detail: `${event.target}:${event.phase}`,
-    quality: "direct",
-    metadata: mergeMetadata(
-      compactMetadata({
-        target: event.target,
-        phase: event.phase,
-        timestamp: event.timestamp,
-        stepIndex: event.stepIndex,
-        parentId: event.parentId,
-        payloadPreview: previewUnknown(event.payload)
-      }),
-      event.metadata
-    )
-  };
+	return {
+		source: "runtime_event",
+		id: event.id,
+		detail: `${event.target}:${event.phase}`,
+		quality: "direct",
+		metadata: mergeMetadata(compactMetadata$1({
+			target: event.target,
+			phase: event.phase,
+			timestamp: event.timestamp,
+			stepIndex: event.stepIndex,
+			parentId: event.parentId,
+			payloadPreview: previewUnknown(event.payload)
+		}), event.metadata)
+	};
 }
 function lifecycleMetadata(refs) {
-  if (refs.length === 0) return void 0;
-  return {
-    lifecycleEventCount: refs.length,
-    lifecycleEventIds: refs.map((ref) => ref.id)
-  };
+	if (refs.length === 0) return void 0;
+	return {
+		lifecycleEventCount: refs.length,
+		lifecycleEventIds: refs.map((ref) => ref.id)
+	};
 }
 function snapshotRuntimeHookEvent(event) {
-  return {
-    id: event.id,
-    runId: event.runId,
-    scenarioId: event.scenarioId,
-    target: event.target,
-    phase: event.phase,
-    timestamp: event.timestamp,
-    stepIndex: event.stepIndex,
-    parentId: event.parentId,
-    payload: snapshotUnknown(event.payload),
-    metadata: event.metadata ? { ...event.metadata } : void 0
-  };
+	return {
+		id: event.id,
+		runId: event.runId,
+		scenarioId: event.scenarioId,
+		target: event.target,
+		phase: event.phase,
+		timestamp: event.timestamp,
+		stepIndex: event.stepIndex,
+		parentId: event.parentId,
+		payload: snapshotUnknown(event.payload),
+		metadata: event.metadata ? { ...event.metadata } : void 0
+	};
 }
 function snapshotRuntimeDecisionPoint(point) {
-  return {
-    id: point.id,
-    runId: point.runId,
-    scenarioId: point.scenarioId,
-    stepIndex: point.stepIndex,
-    kind: point.kind,
-    candidateActions: [...point.candidateActions ?? []],
-    context: point.context,
-    evidence: (point.evidence ?? []).map((ref) => ({
-      source: ref.source,
-      id: ref.id,
-      detail: ref.detail,
-      quality: ref.quality,
-      metadata: ref.metadata ? { ...ref.metadata } : void 0
-    })),
-    metadata: point.metadata ? { ...point.metadata } : void 0
-  };
+	return {
+		id: point.id,
+		runId: point.runId,
+		scenarioId: point.scenarioId,
+		stepIndex: point.stepIndex,
+		kind: point.kind,
+		candidateActions: [...point.candidateActions ?? []],
+		context: point.context,
+		evidence: (point.evidence ?? []).map((ref) => ({
+			source: ref.source,
+			id: ref.id,
+			detail: ref.detail,
+			quality: ref.quality,
+			metadata: ref.metadata ? { ...ref.metadata } : void 0
+		})),
+		metadata: point.metadata ? { ...point.metadata } : void 0
+	};
 }
 function mergeMetadata(base, extra) {
-  if (!base && !extra) return void 0;
-  return { ...base ?? {}, ...extra ?? {} };
+	if (!base && !extra) return void 0;
+	return {
+		...base ?? {},
+		...extra ?? {}
+	};
 }
-function compactMetadata(values) {
-  const entries = Object.entries(values).filter(([, value]) => value !== void 0);
-  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+function compactMetadata$1(values) {
+	const entries = Object.entries(values).filter(([, value]) => value !== void 0);
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 }
 function previewUnknown(value, maxChars = DEFAULT_PAYLOAD_PREVIEW_CHARS) {
-  if (value === void 0) return void 0;
-  if (typeof value === "string") return trimText(value, maxChars);
-  try {
-    return trimText(JSON.stringify(value), maxChars);
-  } catch {
-    return trimText(String(value), maxChars);
-  }
+	if (value === void 0) return void 0;
+	if (typeof value === "string") return trimText$1(value, maxChars);
+	try {
+		return trimText$1(JSON.stringify(value), maxChars);
+	} catch {
+		return trimText$1(String(value), maxChars);
+	}
 }
 function snapshotUnknown(value) {
-  if (Array.isArray(value)) return [...value];
-  if (isRecord2(value)) return { ...value };
-  return value;
+	if (Array.isArray(value)) return [...value];
+	if (isRecord$1(value)) return { ...value };
+	return value;
 }
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function uniqueStrings(values) {
-  return [...new Set(values.filter((value) => value.length > 0))];
+function uniqueStrings$1(values) {
+	return [...new Set(values.filter((value) => value.length > 0))];
 }
-function trimText(value, maxChars = DEFAULT_MAX_CONTEXT_CHARS) {
-  if (!value) return void 0;
-  return value.length > maxChars ? value.slice(value.length - maxChars) : value;
+function trimText$1(value, maxChars = DEFAULT_MAX_CONTEXT_CHARS$1) {
+	if (!value) return void 0;
+	return value.length > maxChars ? value.slice(value.length - maxChars) : value;
 }
 function stringOrUndefined(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
+	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function finiteNumberOrUndefined(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function unitProbabilityOrUndefined(value) {
-  const number = finiteNumberOrUndefined(value);
-  return number !== void 0 && number >= 0 && number <= 1 ? number : void 0;
+	const number = finiteNumberOrUndefined(value);
+	return number !== void 0 && number >= 0 && number <= 1 ? number : void 0;
 }
 function nonNegativeNumberOrUndefined(value) {
-  const number = finiteNumberOrUndefined(value);
-  return number !== void 0 && number >= 0 ? number : void 0;
+	const number = finiteNumberOrUndefined(value);
+	return number !== void 0 && number >= 0 ? number : void 0;
 }
-
-// src/belief-state/phase0-measurement.ts
-var DEFAULT_BASELINE_POLICY_ID = "always-accept-observed-action";
+//#endregion
+//#region src/belief-state/phase0-measurement.ts
+const DEFAULT_BASELINE_POLICY_ID = "always-accept-observed-action";
 function buildRuntimeBeliefPhase0Measurement(options) {
-  const runsById = new Map(options.runs.map((run) => [run.runId, run]));
-  const labelsByDecisionId = /* @__PURE__ */ new Map();
-  const diagnostics = [];
-  for (const label of options.labels) {
-    if (labelsByDecisionId.has(label.decisionId)) {
-      diagnostics.push(`${label.decisionId}: duplicate label; using the last label`);
-    }
-    labelsByDecisionId.set(label.decisionId, label);
-  }
-  const points = [];
-  let missingRunRecordCount = 0;
-  let missingLabelCount = 0;
-  for (const decision of options.decisions) {
-    const run = runsById.get(decision.runId);
-    if (!run) {
-      missingRunRecordCount += 1;
-      diagnostics.push(`${decision.id}: missing RunRecord join for runId ${decision.runId}`);
-      continue;
-    }
-    const label = labelsByDecisionId.get(decision.id);
-    if (!label) {
-      missingLabelCount += 1;
-      diagnostics.push(`${decision.id}: missing observed action/outcome label`);
-      continue;
-    }
-    const splitTag = label.splitTag ?? run.splitTag;
-    const report = runtimeDecisionPointToBeliefDecisionPoint(
-      { ...decision, scenarioId: decision.scenarioId ?? run.scenarioId },
-      {
-        chosenAction: label.chosenAction,
-        confidence: label.confidence,
-        behaviorProb: label.behaviorProb,
-        targetProb: label.targetProb,
-        qHatChosen: label.qHatChosen,
-        vHatTarget: label.vHatTarget,
-        qHat: label.qHat,
-        costUsd: label.costUsd,
-        outcome: label.outcome,
-        lifecycleEvents: options.events,
-        metadata: compactMetadata2({
-          baselinePolicyId: options.baselinePolicyId ?? DEFAULT_BASELINE_POLICY_ID,
-          splitTag,
-          ...label.metadata
-        })
-      }
-    );
-    diagnostics.push(...report.diagnostics.map((item) => `${item.decisionId}: ${item.reason}`));
-    if (report.point) points.push(report.point);
-  }
-  const packet = buildBeliefDecisionResearchEvidencePacket({
-    ...options,
-    points
-  });
-  return {
-    points,
-    packet,
-    summary: summarizePhase0Measurement(options, points, packet, {
-      missingRunRecordCount,
-      missingLabelCount
-    }),
-    diagnostics
-  };
+	const runsById = new Map(options.runs.map((run) => [run.runId, run]));
+	const labelsByDecisionId = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	for (const label of options.labels) {
+		if (labelsByDecisionId.has(label.decisionId)) diagnostics.push(`${label.decisionId}: duplicate label; using the last label`);
+		labelsByDecisionId.set(label.decisionId, label);
+	}
+	const points = [];
+	let missingRunRecordCount = 0;
+	let missingLabelCount = 0;
+	for (const decision of options.decisions) {
+		const run = runsById.get(decision.runId);
+		if (!run) {
+			missingRunRecordCount += 1;
+			diagnostics.push(`${decision.id}: missing RunRecord join for runId ${decision.runId}`);
+			continue;
+		}
+		const label = labelsByDecisionId.get(decision.id);
+		if (!label) {
+			missingLabelCount += 1;
+			diagnostics.push(`${decision.id}: missing observed action/outcome label`);
+			continue;
+		}
+		const splitTag = label.splitTag ?? run.splitTag;
+		const report = runtimeDecisionPointToBeliefDecisionPoint({
+			...decision,
+			scenarioId: decision.scenarioId ?? run.scenarioId
+		}, {
+			chosenAction: label.chosenAction,
+			confidence: label.confidence,
+			behaviorProb: label.behaviorProb,
+			targetProb: label.targetProb,
+			qHatChosen: label.qHatChosen,
+			vHatTarget: label.vHatTarget,
+			costUsd: label.costUsd,
+			outcome: label.outcome,
+			lifecycleEvents: options.events,
+			metadata: compactMetadata({
+				baselinePolicyId: options.baselinePolicyId ?? DEFAULT_BASELINE_POLICY_ID,
+				splitTag,
+				...label.metadata
+			})
+		});
+		diagnostics.push(...report.diagnostics.map((item) => `${item.decisionId}: ${item.reason}`));
+		if (report.point) points.push(report.point);
+	}
+	const packet = buildBeliefDecisionResearchEvidencePacket({
+		...options,
+		points
+	});
+	return {
+		points,
+		packet,
+		summary: summarizePhase0Measurement(options, points, packet, {
+			missingRunRecordCount,
+			missingLabelCount
+		}),
+		diagnostics
+	};
 }
 function summarizePhase0Measurement(options, points, packet, counts) {
-  const producerDecisionCount = options.decisions.length;
-  return {
-    runCount: options.runs.length,
-    producerDecisionCount,
-    lifecycleEventCount: options.events?.length ?? 0,
-    labelCount: options.labels.length,
-    completedPointCount: points.length,
-    runJoinRate: ratio(producerDecisionCount - counts.missingRunRecordCount, producerDecisionCount),
-    labelJoinRate: ratio(points.length, producerDecisionCount),
-    missingRunRecordCount: counts.missingRunRecordCount,
-    missingLabelCount: counts.missingLabelCount,
-    withEvidence: points.filter((point) => point.evidence.length > 0).length,
-    withOutcome: points.filter((point) => point.outcome).length,
-    withSplit: points.filter((point) => typeof point.metadata?.splitTag === "string").length,
-    withBehaviorProb: points.filter((point) => point.behaviorProb !== void 0).length,
-    withTargetProb: points.filter((point) => point.targetProb !== void 0).length,
-    baselinePolicyId: options.baselinePolicyId ?? DEFAULT_BASELINE_POLICY_ID,
-    packetStatus: packet.status,
-    claimScope: packet.claimScope
-  };
+	const producerDecisionCount = options.decisions.length;
+	return {
+		runCount: options.runs.length,
+		producerDecisionCount,
+		lifecycleEventCount: options.events?.length ?? 0,
+		labelCount: options.labels.length,
+		completedPointCount: points.length,
+		runJoinRate: ratio(producerDecisionCount - counts.missingRunRecordCount, producerDecisionCount),
+		labelJoinRate: ratio(points.length, producerDecisionCount),
+		missingRunRecordCount: counts.missingRunRecordCount,
+		missingLabelCount: counts.missingLabelCount,
+		withEvidence: points.filter((point) => point.evidence.length > 0).length,
+		withOutcome: points.filter((point) => point.outcome).length,
+		withSplit: points.filter((point) => typeof point.metadata?.splitTag === "string").length,
+		withBehaviorProb: points.filter((point) => point.behaviorProb !== void 0).length,
+		withTargetProb: points.filter((point) => point.targetProb !== void 0).length,
+		baselinePolicyId: options.baselinePolicyId ?? DEFAULT_BASELINE_POLICY_ID,
+		packetStatus: packet.status,
+		claimScope: packet.claimScope
+	};
 }
 function ratio(numerator, denominator) {
-  return denominator > 0 ? numerator / denominator : 0;
+	return denominator > 0 ? numerator / denominator : 0;
 }
-function compactMetadata2(values) {
-  const entries = Object.entries(values).filter(([, value]) => value !== void 0);
-  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
-}
-
-// src/belief-state/runtime-benchmark-corpus.ts
-var MAX_STRING_LENGTH = 12e3;
-var MAX_CONTEXT_LENGTH = 2e4;
-var MAX_EVIDENCE_DETAIL_LENGTH = 2e3;
-var MAX_CANDIDATE_ACTIONS = 50;
-var MAX_EVIDENCE_REFS = 50;
-var MAX_METADATA_DEPTH = 4;
-var MAX_METADATA_KEYS = 100;
-var SENSITIVE_KEY_RE = /(?:authorization|api[_-]?key|token|secret|password|cookie|credential|bearer)/i;
-var SENSITIVE_VALUE_RES = [
-  /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi,
-  /\b(?:sk|gh[pousr])_[A-Za-z0-9_]{20,}\b/g,
-  /\b(?:sk|ghp|gho|ghu|ghs|ghr)-[A-Za-z0-9_-]{20,}\b/g
+function compactMetadata(values) {
+	const entries = Object.entries(values).filter(([, value]) => value !== void 0);
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+//#endregion
+//#region src/belief-state/runtime-benchmark-corpus.ts
+const MAX_STRING_LENGTH = 12e3;
+const MAX_CONTEXT_LENGTH = 2e4;
+const MAX_EVIDENCE_DETAIL_LENGTH = 2e3;
+const MAX_CANDIDATE_ACTIONS = 50;
+const MAX_EVIDENCE_REFS = 50;
+const MAX_METADATA_DEPTH = 4;
+const MAX_METADATA_KEYS = 100;
+const SENSITIVE_KEY_RE = /(?:authorization|api[_-]?key|token|secret|password|cookie|credential|bearer)/i;
+const SENSITIVE_VALUE_RES = [
+	/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi,
+	/\b(?:sk|gh[pousr])_[A-Za-z0-9_]{20,}\b/g,
+	/\b(?:sk|ghp|gho|ghu|ghs|ghr)-[A-Za-z0-9_-]{20,}\b/g
 ];
-var SENSITIVE_ASSIGNMENT_RE = /\b(api[_-]?key|token|secret|password|cookie)\s*[:=]\s*["']?[^"'\s,;}]+/gi;
+const SENSITIVE_ASSIGNMENT_RE = /\b(api[_-]?key|token|secret|password|cookie)\s*[:=]\s*["']?[^"'\s,;}]+/gi;
 function buildRuntimeBenchmarkBeliefPhase0Measurement(options) {
-  const diagnostics = [];
-  const trajectory = projectRuntimeTrajectoryEvidence({
-    records: options.records,
-    defaultSplitTag: options.defaultSplitTag,
-    recordIdOf: runtimeBenchmarkRecordId,
-    scenarioIdOf: runtimeBenchmarkScenarioId
-  });
-  const decisions = options.decisions ?? runtimeBenchmarkDecisionPoints(options.records, diagnostics);
-  const labels = options.labels ?? [];
-  if (decisions.length === 0) {
-    diagnostics.push(
-      "no runtime decision points supplied or found on records; benchmark lifecycle events alone cannot produce belief decision rows"
-    );
-  }
-  if (labels.length === 0 && decisions.length > 0) {
-    diagnostics.push(
-      "no decision labels supplied; observed action/outcome joins will be incomplete"
-    );
-  }
-  const measurement = buildRuntimeBeliefPhase0Measurement({
-    ...options,
-    runs: trajectory.runs,
-    events: trajectory.events,
-    decisions,
-    labels
-  });
-  return {
-    runs: trajectory.runs,
-    events: trajectory.events,
-    decisions,
-    labels,
-    trajectory,
-    measurement,
-    summary: {
-      decisionCount: decisions.length,
-      labelCount: labels.length
-    },
-    diagnostics: [...trajectory.diagnostics, ...diagnostics, ...measurement.diagnostics]
-  };
+	const diagnostics = [];
+	const trajectory = projectRuntimeTrajectoryEvidence({
+		records: options.records,
+		defaultSplitTag: options.defaultSplitTag,
+		recordIdOf: runtimeBenchmarkRecordId,
+		scenarioIdOf: runtimeBenchmarkScenarioId
+	});
+	const decisions = options.decisions ?? runtimeBenchmarkDecisionPoints(options.records, diagnostics);
+	const labels = options.labels ?? [];
+	if (decisions.length === 0) diagnostics.push("no runtime decision points supplied or found on records; benchmark lifecycle events alone cannot produce belief decision rows");
+	if (labels.length === 0 && decisions.length > 0) diagnostics.push("no decision labels supplied; observed action/outcome joins will be incomplete");
+	const measurement = buildRuntimeBeliefPhase0Measurement({
+		...options,
+		runs: trajectory.runs,
+		events: trajectory.events,
+		decisions,
+		labels
+	});
+	return {
+		runs: trajectory.runs,
+		events: trajectory.events,
+		decisions,
+		labels,
+		trajectory,
+		measurement,
+		summary: {
+			decisionCount: decisions.length,
+			labelCount: labels.length
+		},
+		diagnostics: [
+			...trajectory.diagnostics,
+			...diagnostics,
+			...measurement.diagnostics
+		]
+	};
 }
 function runtimeBenchmarkRecordId(record) {
-  const parts = [
-    nonEmptyString(record.benchmark),
-    nonEmptyString(record.instanceId),
-    nonEmptyString(record.condition)
-  ].filter((part) => part !== void 0);
-  return parts.length > 0 ? parts.join(":") : void 0;
+	const parts = [
+		nonEmptyString(record.benchmark),
+		nonEmptyString(record.instanceId),
+		nonEmptyString(record.condition)
+	].filter((part) => part !== void 0);
+	return parts.length > 0 ? parts.join(":") : void 0;
 }
 function runtimeBenchmarkScenarioId(record) {
-  return nonEmptyString(record.instanceId);
+	return nonEmptyString(record.instanceId);
 }
 function runtimeBenchmarkDecisionPoints(records, diagnostics) {
-  const decisions = [];
-  for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
-    const record = records[recordIndex];
-    const raw = record.runtimeDecisionPoints;
-    if (raw === void 0) continue;
-    const recordId = runtimeBenchmarkRecordId(record) ?? `record[${recordIndex}]`;
-    if (!Array.isArray(raw)) {
-      diagnostics.push(`${recordId}: runtimeDecisionPoints is not an array`);
-      continue;
-    }
-    for (let pointIndex = 0; pointIndex < raw.length; pointIndex += 1) {
-      const point = runtimeBenchmarkDecisionPoint(raw[pointIndex], {
-        diagnostics,
-        path: `${recordId}: runtimeDecisionPoints[${pointIndex}]`
-      });
-      if (!point) {
-        diagnostics.push(
-          `${recordId}: runtimeDecisionPoints[${pointIndex}] is not a RuntimeDecisionPoint`
-        );
-        continue;
-      }
-      decisions.push(point);
-    }
-  }
-  return decisions;
+	const decisions = [];
+	for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+		const record = records[recordIndex];
+		const raw = record.runtimeDecisionPoints;
+		if (raw === void 0) continue;
+		const recordId = runtimeBenchmarkRecordId(record) ?? `record[${recordIndex}]`;
+		if (!Array.isArray(raw)) {
+			diagnostics.push(`${recordId}: runtimeDecisionPoints is not an array`);
+			continue;
+		}
+		for (let pointIndex = 0; pointIndex < raw.length; pointIndex += 1) {
+			const point = runtimeBenchmarkDecisionPoint(raw[pointIndex], {
+				diagnostics,
+				path: `${recordId}: runtimeDecisionPoints[${pointIndex}]`
+			});
+			if (!point) {
+				diagnostics.push(`${recordId}: runtimeDecisionPoints[${pointIndex}] is not a RuntimeDecisionPoint`);
+				continue;
+			}
+			decisions.push(point);
+		}
+	}
+	return decisions;
 }
 function runtimeBenchmarkDecisionPoint(input, context) {
-  if (!isRecord3(input)) return null;
-  if (typeof input.id !== "string" || input.id.length === 0) return null;
-  if (typeof input.runId !== "string" || input.runId.length === 0) return null;
-  if (typeof input.stepIndex !== "number" || !Number.isInteger(input.stepIndex) || input.stepIndex < 0) {
-    return null;
-  }
-  if (typeof input.kind !== "string" || input.kind.length === 0) return null;
-  return {
-    id: sanitizeString(input.id, MAX_STRING_LENGTH),
-    runId: sanitizeString(input.runId, MAX_STRING_LENGTH),
-    scenarioId: sanitizeOptionalString(input.scenarioId, MAX_STRING_LENGTH),
-    stepIndex: input.stepIndex,
-    kind: sanitizeString(input.kind, MAX_STRING_LENGTH),
-    candidateActions: stringArray(input.candidateActions, {
-      ...context,
-      maxItems: MAX_CANDIDATE_ACTIONS,
-      label: "candidateActions"
-    }),
-    context: sanitizeOptionalString(input.context, MAX_CONTEXT_LENGTH),
-    evidence: runtimeBenchmarkEvidence(input.evidence, context),
-    metadata: sanitizeMetadataRecord(input.metadata)
-  };
+	if (!isRecord(input)) return null;
+	if (typeof input.id !== "string" || input.id.length === 0) return null;
+	if (typeof input.runId !== "string" || input.runId.length === 0) return null;
+	if (typeof input.stepIndex !== "number" || !Number.isInteger(input.stepIndex) || input.stepIndex < 0) return null;
+	if (typeof input.kind !== "string" || input.kind.length === 0) return null;
+	return {
+		id: sanitizeString(input.id, MAX_STRING_LENGTH),
+		runId: sanitizeString(input.runId, MAX_STRING_LENGTH),
+		scenarioId: sanitizeOptionalString(input.scenarioId, MAX_STRING_LENGTH),
+		stepIndex: input.stepIndex,
+		kind: sanitizeString(input.kind, MAX_STRING_LENGTH),
+		candidateActions: stringArray(input.candidateActions, {
+			...context,
+			maxItems: MAX_CANDIDATE_ACTIONS,
+			label: "candidateActions"
+		}),
+		context: sanitizeOptionalString(input.context, MAX_CONTEXT_LENGTH),
+		evidence: runtimeBenchmarkEvidence(input.evidence, context),
+		metadata: sanitizeMetadataRecord(input.metadata)
+	};
 }
 function runtimeBenchmarkEvidence(input, context) {
-  if (!Array.isArray(input)) return [];
-  if (input.length > MAX_EVIDENCE_REFS) {
-    context.diagnostics.push(`${context.path}: evidence truncated to ${MAX_EVIDENCE_REFS} refs`);
-  }
-  return input.slice(0, MAX_EVIDENCE_REFS).flatMap((item) => {
-    if (!isRecord3(item)) return [];
-    const source = sanitizeOptionalString(item.source, MAX_STRING_LENGTH);
-    const id = sanitizeOptionalString(item.id, MAX_STRING_LENGTH);
-    if (!source || !id) return [];
-    return [
-      {
-        source,
-        id,
-        detail: sanitizeOptionalString(item.detail, MAX_EVIDENCE_DETAIL_LENGTH),
-        metadata: sanitizeMetadataRecord(item.metadata)
-      }
-    ];
-  });
+	if (!Array.isArray(input)) return [];
+	if (input.length > MAX_EVIDENCE_REFS) context.diagnostics.push(`${context.path}: evidence truncated to ${MAX_EVIDENCE_REFS} refs`);
+	return input.slice(0, MAX_EVIDENCE_REFS).flatMap((item) => {
+		if (!isRecord(item)) return [];
+		const source = sanitizeOptionalString(item.source, MAX_STRING_LENGTH);
+		const id = sanitizeOptionalString(item.id, MAX_STRING_LENGTH);
+		if (!source || !id) return [];
+		return [{
+			source,
+			id,
+			detail: sanitizeOptionalString(item.detail, MAX_EVIDENCE_DETAIL_LENGTH),
+			metadata: sanitizeMetadataRecord(item.metadata)
+		}];
+	});
 }
 function stringArray(input, context) {
-  if (!Array.isArray(input)) return void 0;
-  if (input.length > context.maxItems) {
-    context.diagnostics.push(`${context.path}: ${context.label} truncated to ${context.maxItems}`);
-  }
-  const values = input.slice(0, context.maxItems).filter((value) => typeof value === "string" && value.length > 0).map((value) => sanitizeString(value, MAX_STRING_LENGTH));
-  return values.length > 0 ? values : void 0;
+	if (!Array.isArray(input)) return void 0;
+	if (input.length > context.maxItems) context.diagnostics.push(`${context.path}: ${context.label} truncated to ${context.maxItems}`);
+	const values = input.slice(0, context.maxItems).filter((value) => typeof value === "string" && value.length > 0).map((value) => sanitizeString(value, MAX_STRING_LENGTH));
+	return values.length > 0 ? values : void 0;
 }
 function sanitizeMetadataRecord(metadata) {
-  if (!isRecord3(metadata)) return void 0;
-  const sanitized = sanitizeMetadata(metadata);
-  if (!sanitized || typeof sanitized !== "object" || Array.isArray(sanitized)) return void 0;
-  return sanitized;
+	if (!isRecord(metadata)) return void 0;
+	const sanitized = sanitizeMetadata(metadata);
+	if (!sanitized || typeof sanitized !== "object" || Array.isArray(sanitized)) return void 0;
+	return sanitized;
 }
 function sanitizeMetadata(value, depth = 0) {
-  if (value == null) return value;
-  if (typeof value === "string") return sanitizeString(value, MAX_STRING_LENGTH);
-  if (typeof value === "number" || typeof value === "boolean") return value;
-  if (Array.isArray(value)) {
-    if (depth >= MAX_METADATA_DEPTH) return "[MaxDepth]";
-    return value.slice(0, MAX_METADATA_KEYS).map((item) => sanitizeMetadata(item, depth + 1));
-  }
-  if (!isRecord3(value)) return void 0;
-  if (depth >= MAX_METADATA_DEPTH) return "[MaxDepth]";
-  const sanitized = {};
-  for (const [key, nested] of Object.entries(value).slice(0, MAX_METADATA_KEYS)) {
-    sanitized[key] = SENSITIVE_KEY_RE.test(key) ? "[REDACTED]" : sanitizeMetadata(nested, depth + 1);
-  }
-  return sanitized;
+	if (value == null) return value;
+	if (typeof value === "string") return sanitizeString(value, MAX_STRING_LENGTH);
+	if (typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) {
+		if (depth >= MAX_METADATA_DEPTH) return "[MaxDepth]";
+		return value.slice(0, MAX_METADATA_KEYS).map((item) => sanitizeMetadata(item, depth + 1));
+	}
+	if (!isRecord(value)) return void 0;
+	if (depth >= MAX_METADATA_DEPTH) return "[MaxDepth]";
+	const sanitized = {};
+	for (const [key, nested] of Object.entries(value).slice(0, MAX_METADATA_KEYS)) sanitized[key] = SENSITIVE_KEY_RE.test(key) ? "[REDACTED]" : sanitizeMetadata(nested, depth + 1);
+	return sanitized;
 }
 function sanitizeOptionalString(value, maxLength) {
-  return typeof value === "string" && value.length > 0 ? sanitizeString(value, maxLength) : void 0;
+	return typeof value === "string" && value.length > 0 ? sanitizeString(value, maxLength) : void 0;
 }
 function sanitizeString(value, maxLength) {
-  let sanitized = value;
-  for (const pattern of SENSITIVE_VALUE_RES) {
-    sanitized = sanitized.replace(pattern, "[REDACTED]");
-  }
-  sanitized = sanitized.replace(
-    SENSITIVE_ASSIGNMENT_RE,
-    (_match, key) => `${key}=[REDACTED]`
-  );
-  if (sanitized.length <= maxLength) return sanitized;
-  return sanitized.slice(0, maxLength);
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+	let sanitized = value;
+	for (const pattern of SENSITIVE_VALUE_RES) sanitized = sanitized.replace(pattern, "[REDACTED]");
+	sanitized = sanitized.replace(SENSITIVE_ASSIGNMENT_RE, (_match, key) => `${key}=[REDACTED]`);
+	if (sanitized.length <= maxLength) return sanitized;
+	return sanitized.slice(0, maxLength);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
+	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-
-// src/belief-state/shadow-probe.ts
-var DEFAULT_CONCURRENCY = 4;
-var DEFAULT_MAX_CONTEXT_CHARS2 = 12e3;
+//#endregion
+//#region src/belief-state/shadow-probe.ts
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_MAX_CONTEXT_CHARS = 12e3;
 async function runBeliefShadowProbe(options) {
-  const concurrency = boundedInteger(options.concurrency ?? DEFAULT_CONCURRENCY, 1, 32);
-  const records = [];
-  const diagnostics = [];
-  let next = 0;
-  async function worker() {
-    while (next < options.points.length) {
-      const index = next;
-      next += 1;
-      const point = options.points[index];
-      if (!point) continue;
-      const result = await probePoint(point, options);
-      records[index] = result.record;
-      diagnostics.push(...result.diagnostics);
-    }
-  }
-  await Promise.all(Array.from({ length: Math.min(concurrency, options.points.length) }, worker));
-  const completed = records.filter((record) => !!record);
-  return {
-    probeId: options.probeId,
-    records: completed,
-    diagnostics,
-    summary: summarizeShadowProbe(options.points.length, completed)
-  };
+	const concurrency = boundedInteger(options.concurrency ?? DEFAULT_CONCURRENCY, 1, 32);
+	const records = [];
+	const diagnostics = [];
+	let next = 0;
+	async function worker() {
+		while (next < options.points.length) {
+			const index = next;
+			next += 1;
+			const point = options.points[index];
+			if (!point) continue;
+			const result = await probePoint(point, options);
+			records[index] = result.record;
+			diagnostics.push(...result.diagnostics);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(concurrency, options.points.length) }, worker));
+	const completed = records.filter((record) => !!record);
+	return {
+		probeId: options.probeId,
+		records: completed,
+		diagnostics,
+		summary: summarizeShadowProbe(options.points.length, completed)
+	};
 }
 function formatBeliefShadowProbePrompt(input) {
-  return [
-    "Return only JSON. Do not include chain-of-thought.",
-    "Infer the agent belief state at this decision boundary using only the context below.",
-    "",
-    `decisionKind: ${input.decisionKind}`,
-    `candidateActions: ${JSON.stringify(input.candidateActions)}`,
-    input.observedAction ? `observedAction: ${JSON.stringify(input.observedAction)}` : "",
-    input.context ? `context:
-${input.context}` : "",
-    "",
-    "Schema:",
-    JSON.stringify({
-      predictedAction: "one candidate action",
-      confidence: "number in [0,1]",
-      beliefSummary: "short outcome-blind summary",
-      uncertainty: ["short uncertainty"],
-      evidenceRefs: ["evidence id"],
-      wouldChangeMindIf: ["observable evidence"],
-      targetProb: "optional number in [0,1]",
-      qHat: "optional number in [0,1]"
-    })
-  ].filter(Boolean).join("\n");
+	return [
+		"Return only JSON. Do not include chain-of-thought.",
+		"Infer the agent belief state at this decision boundary using only the context below.",
+		"",
+		`decisionKind: ${input.decisionKind}`,
+		`candidateActions: ${JSON.stringify(input.candidateActions)}`,
+		input.observedAction ? `observedAction: ${JSON.stringify(input.observedAction)}` : "",
+		input.context ? `context:\n${input.context}` : "",
+		"",
+		"Schema:",
+		JSON.stringify({
+			predictedAction: "one candidate action",
+			confidence: "number in [0,1]",
+			beliefSummary: "short outcome-blind summary",
+			uncertainty: ["short uncertainty"],
+			evidenceRefs: ["evidence id"],
+			wouldChangeMindIf: ["observable evidence"],
+			targetProb: "optional number in [0,1]",
+			qHatChosen: "optional number in [0,1], paired with vHatTarget",
+			vHatTarget: "optional number in [0,1], paired with qHatChosen"
+		})
+	].filter(Boolean).join("\n");
 }
 async function probePoint(point, options) {
-  const diagnostics = [];
-  const candidateActions = uniqueStrings2(point.candidateActions ?? []);
-  if ((options.requireCandidateActions ?? true) && candidateActions.length === 0) {
-    diagnostics.push({
-      decisionId: point.id,
-      severity: "warning",
-      reason: "missing candidateActions"
-    });
-    return { diagnostics };
-  }
-  let response;
-  try {
-    response = await options.probe({
-      probeId: options.probeId,
-      decisionId: point.id,
-      runId: point.runId,
-      scenarioId: point.scenarioId,
-      stepIndex: point.stepIndex,
-      decisionKind: point.kind,
-      candidateActions,
-      ...options.includeObservedAction ? { observedAction: point.chosenAction } : {},
-      evidence: point.evidence.map((ref) => ({
-        id: ref.id,
-        source: ref.source,
-        ...options.includeEvidenceDetail && ref.detail ? { detail: ref.detail } : {},
-        ...ref.quality ? { quality: ref.quality } : {}
-      })),
-      context: trimText2(await options.contextOf?.(point), options.maxContextChars),
-      metadata: await options.metadataOf?.(point)
-    });
-  } catch (error) {
-    diagnostics.push({
-      decisionId: point.id,
-      severity: "error",
-      reason: `probe threw: ${errorMessage2(error)}`
-    });
-    return { diagnostics };
-  }
-  const normalized = normalizeProbeResponse(response, {
-    point,
-    candidateActions,
-    allowOutOfSetActions: options.allowOutOfSetActions ?? false
-  });
-  if (!normalized.record) {
-    diagnostics.push(...normalized.diagnostics);
-    return { diagnostics };
-  }
-  return {
-    record: {
-      probeId: options.probeId,
-      decisionId: point.id,
-      runId: point.runId,
-      scenarioId: point.scenarioId,
-      stepIndex: point.stepIndex,
-      decisionKind: point.kind,
-      candidateActions,
-      observedAction: point.chosenAction,
-      agreesWithObservedAction: normalized.record.predictedAction === point.chosenAction,
-      ...options.includeOutcomeInRecord === false ? {} : { outcome: point.outcome },
-      ...normalized.record
-    },
-    diagnostics
-  };
+	const diagnostics = [];
+	const candidateActions = uniqueStrings(point.candidateActions ?? []);
+	if ((options.requireCandidateActions ?? true) && candidateActions.length === 0) {
+		diagnostics.push({
+			decisionId: point.id,
+			severity: "warning",
+			reason: "missing candidateActions"
+		});
+		return { diagnostics };
+	}
+	let response;
+	try {
+		response = await options.probe({
+			probeId: options.probeId,
+			decisionId: point.id,
+			runId: point.runId,
+			scenarioId: point.scenarioId,
+			stepIndex: point.stepIndex,
+			decisionKind: point.kind,
+			candidateActions,
+			...options.includeObservedAction ? { observedAction: point.chosenAction } : {},
+			evidence: point.evidence.map((ref) => ({
+				id: ref.id,
+				source: ref.source,
+				...options.includeEvidenceDetail && ref.detail ? { detail: ref.detail } : {},
+				...ref.quality ? { quality: ref.quality } : {}
+			})),
+			context: trimText(await options.contextOf?.(point), options.maxContextChars),
+			metadata: await options.metadataOf?.(point)
+		});
+	} catch (error) {
+		diagnostics.push({
+			decisionId: point.id,
+			severity: "error",
+			reason: `probe threw: ${errorMessage(error)}`
+		});
+		return { diagnostics };
+	}
+	const normalized = normalizeProbeResponse(response, {
+		point,
+		candidateActions,
+		allowOutOfSetActions: options.allowOutOfSetActions ?? false
+	});
+	if (!normalized.record) {
+		diagnostics.push(...normalized.diagnostics);
+		return { diagnostics };
+	}
+	return {
+		record: {
+			probeId: options.probeId,
+			decisionId: point.id,
+			runId: point.runId,
+			scenarioId: point.scenarioId,
+			stepIndex: point.stepIndex,
+			decisionKind: point.kind,
+			candidateActions,
+			observedAction: point.chosenAction,
+			agreesWithObservedAction: normalized.record.predictedAction === point.chosenAction,
+			...options.includeOutcomeInRecord === false ? {} : { outcome: point.outcome },
+			...normalized.record
+		},
+		diagnostics
+	};
 }
 function normalizeProbeResponse(response, options) {
-  const diagnostics = [];
-  const predictedAction = stringOrNull(response.predictedAction);
-  if (!predictedAction) {
-    diagnostics.push({
-      decisionId: options.point.id,
-      severity: "error",
-      reason: "missing predictedAction"
-    });
-  } else if (!options.allowOutOfSetActions && options.candidateActions.length > 0 && !options.candidateActions.includes(predictedAction)) {
-    diagnostics.push({
-      decisionId: options.point.id,
-      severity: "error",
-      reason: `predictedAction ${predictedAction} is not in candidateActions`
-    });
-  }
-  if (!isUnitProbability(response.confidence)) {
-    diagnostics.push({
-      decisionId: options.point.id,
-      severity: "error",
-      reason: `invalid confidence ${String(response.confidence)}`
-    });
-  }
-  if (response.targetProb !== void 0 && !isUnitProbability(response.targetProb)) {
-    diagnostics.push({
-      decisionId: options.point.id,
-      severity: "error",
-      reason: `invalid targetProb ${String(response.targetProb)}`
-    });
-  }
-  if (response.qHat !== void 0 && response.qHat !== null && !isUnitProbability(response.qHat)) {
-    diagnostics.push({
-      decisionId: options.point.id,
-      severity: "error",
-      reason: `invalid qHat ${String(response.qHat)}`
-    });
-  }
-  if (diagnostics.length > 0 || !predictedAction) return { diagnostics };
-  return {
-    record: {
-      predictedAction,
-      confidence: response.confidence,
-      ...response.beliefSummary ? { beliefSummary: trimText2(response.beliefSummary, 2e3) } : {},
-      uncertainty: compactStrings(response.uncertainty),
-      evidenceRefs: compactStrings(response.evidenceRefs),
-      wouldChangeMindIf: compactStrings(response.wouldChangeMindIf),
-      ...response.targetProb !== void 0 ? { targetProb: response.targetProb } : {},
-      ...response.qHat !== void 0 ? { qHat: response.qHat } : {},
-      ...response.metadata ? { metadata: response.metadata } : {}
-    },
-    diagnostics
-  };
+	const diagnostics = [];
+	const predictedAction = stringOrNull(response.predictedAction);
+	if (!predictedAction) diagnostics.push({
+		decisionId: options.point.id,
+		severity: "error",
+		reason: "missing predictedAction"
+	});
+	else if (!options.allowOutOfSetActions && options.candidateActions.length > 0 && !options.candidateActions.includes(predictedAction)) diagnostics.push({
+		decisionId: options.point.id,
+		severity: "error",
+		reason: `predictedAction ${predictedAction} is not in candidateActions`
+	});
+	if (!isUnitProbability(response.confidence)) diagnostics.push({
+		decisionId: options.point.id,
+		severity: "error",
+		reason: `invalid confidence ${String(response.confidence)}`
+	});
+	if (response.targetProb !== void 0 && !isUnitProbability(response.targetProb)) diagnostics.push({
+		decisionId: options.point.id,
+		severity: "error",
+		reason: `invalid targetProb ${String(response.targetProb)}`
+	});
+	const hasQHatChosen = response.qHatChosen !== void 0 && response.qHatChosen !== null;
+	const hasVHatTarget = response.vHatTarget !== void 0 && response.vHatTarget !== null;
+	if (hasQHatChosen !== hasVHatTarget) diagnostics.push({
+		decisionId: options.point.id,
+		severity: "error",
+		reason: "qHatChosen and vHatTarget must be supplied together"
+	});
+	if (hasQHatChosen && !isUnitProbability(response.qHatChosen)) diagnostics.push({
+		decisionId: options.point.id,
+		severity: "error",
+		reason: `invalid qHatChosen ${String(response.qHatChosen)}`
+	});
+	if (hasVHatTarget && !isUnitProbability(response.vHatTarget)) diagnostics.push({
+		decisionId: options.point.id,
+		severity: "error",
+		reason: `invalid vHatTarget ${String(response.vHatTarget)}`
+	});
+	if (diagnostics.length > 0 || !predictedAction) return { diagnostics };
+	return {
+		record: {
+			predictedAction,
+			confidence: response.confidence,
+			...response.beliefSummary ? { beliefSummary: trimText(response.beliefSummary, 2e3) } : {},
+			uncertainty: compactStrings(response.uncertainty),
+			evidenceRefs: compactStrings(response.evidenceRefs),
+			wouldChangeMindIf: compactStrings(response.wouldChangeMindIf),
+			...response.targetProb !== void 0 ? { targetProb: response.targetProb } : {},
+			...response.qHatChosen !== void 0 ? { qHatChosen: response.qHatChosen } : {},
+			...response.vHatTarget !== void 0 ? { vHatTarget: response.vHatTarget } : {},
+			...response.metadata ? { metadata: response.metadata } : {}
+		},
+		diagnostics
+	};
 }
 function summarizeShadowProbe(attempted, records) {
-  const confidences = records.map((record) => record.confidence);
-  const agreements = records.filter((record) => record.agreesWithObservedAction).length;
-  return {
-    attempted,
-    completed: records.length,
-    dropped: attempted - records.length,
-    withOutcome: records.filter((record) => record.outcome !== void 0).length,
-    withTargetProb: records.filter((record) => record.targetProb !== void 0).length,
-    meanConfidence: confidences.length > 0 ? mean3(confidences) : null,
-    observedAgreementRate: records.length > 0 ? agreements / records.length : null
-  };
+	const confidences = records.map((record) => record.confidence);
+	const agreements = records.filter((record) => record.agreesWithObservedAction).length;
+	return {
+		attempted,
+		completed: records.length,
+		dropped: attempted - records.length,
+		withOutcome: records.filter((record) => record.outcome !== void 0).length,
+		withTargetProb: records.filter((record) => record.targetProb !== void 0).length,
+		meanConfidence: confidences.length > 0 ? mean(confidences) : null,
+		observedAgreementRate: records.length > 0 ? agreements / records.length : null
+	};
 }
 function isUnitProbability(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
 }
 function boundedInteger(value, min, max) {
-  if (!Number.isFinite(value)) return min;
-  return Math.max(min, Math.min(max, Math.floor(value)));
+	if (!Number.isFinite(value)) return min;
+	return Math.max(min, Math.min(max, Math.floor(value)));
 }
 function compactStrings(values, maxItems = 12) {
-  if (!Array.isArray(values)) return [];
-  return values.filter((value) => typeof value === "string" && value.length > 0).slice(0, maxItems).map((value) => trimText2(value, 500) ?? "").filter(Boolean);
+	if (!Array.isArray(values)) return [];
+	return values.filter((value) => typeof value === "string" && value.length > 0).slice(0, maxItems).map((value) => trimText(value, 500) ?? "").filter(Boolean);
 }
-function uniqueStrings2(values) {
-  return [...new Set(values.filter((value) => value.length > 0))];
+function uniqueStrings(values) {
+	return [...new Set(values.filter((value) => value.length > 0))];
 }
 function stringOrNull(value) {
-  return typeof value === "string" && value.length > 0 ? value : null;
-}
-function trimText2(value, maxChars = DEFAULT_MAX_CONTEXT_CHARS2) {
-  if (!value) return void 0;
-  return value.length > maxChars ? value.slice(value.length - maxChars) : value;
-}
-function mean3(values) {
-  return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-function errorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-export {
-  BELIEF_DECISION_KINDS,
-  BELIEF_EVALUATION_CRITERIA,
-  BELIEF_EVIDENCE_QUALITIES,
-  BELIEF_EVIDENCE_SOURCES,
-  analyzeBeliefDecisionCorpus,
-  analyzeBeliefPolicy,
-  beliefDecisionsToOffPolicyTrajectories,
-  buildBeliefDecisionResearchEvidencePacket,
-  buildCodeAgentBeliefEvidenceCorpus,
-  buildRuntimeBeliefPhase0Measurement,
-  buildRuntimeBenchmarkBeliefPhase0Measurement,
-  calibrateBeliefDecisions,
-  createBeliefRuntimeHookCollector,
-  embeddedBeliefOpeTargetPolicy,
-  evaluateBeliefOffPolicy,
-  evaluateBeliefSelectivePolicy,
-  extractBeliefDecisionPoints,
-  extractCodeAgentBeliefDecisionPoints,
-  formatBeliefShadowProbePrompt,
-  inventoryBeliefDecisionPoints,
-  isBeliefDecisionKind,
-  isBeliefEvidenceSource,
-  runBeliefShadowProbe,
-  runtimeDecisionPointToBeliefDecisionPoint,
-  runtimeDecisionPointToBeliefShadowProbeInput,
-  selectBeliefDecisionTarget,
-  thresholdSelectivePolicy
-};
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function trimText(value, maxChars = DEFAULT_MAX_CONTEXT_CHARS) {
+	if (!value) return void 0;
+	return value.length > maxChars ? value.slice(value.length - maxChars) : value;
+}
+function mean(values) {
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { BELIEF_DECISION_KINDS, BELIEF_EVALUATION_CRITERIA, BELIEF_EVIDENCE_QUALITIES, BELIEF_EVIDENCE_SOURCES, analyzeBeliefDecisionCorpus, analyzeBeliefPolicy, beliefDecisionsToOffPolicyTrajectories, buildBeliefDecisionResearchEvidencePacket, buildCodeAgentBeliefEvidenceCorpus, buildRuntimeBeliefPhase0Measurement, buildRuntimeBenchmarkBeliefPhase0Measurement, calibrateBeliefDecisions, createBeliefRuntimeHookCollector, embeddedBeliefOpeTargetPolicy, evaluateBeliefOffPolicy, evaluateBeliefSelectivePolicy, extractBeliefDecisionPoints, extractCodeAgentBeliefDecisionPoints, formatBeliefShadowProbePrompt, inventoryBeliefDecisionPoints, isBeliefDecisionKind, isBeliefEvidenceSource, runBeliefShadowProbe, runtimeDecisionPointToBeliefDecisionPoint, runtimeDecisionPointToBeliefShadowProbeInput, selectBeliefDecisionTarget, thresholdSelectivePolicy };
+
 //# sourceMappingURL=index.js.map