@tangle-network/agent-eval 0.131.1 → 0.133.0

package/dist/belief-state/index.js

@@ -1,1819 +0,0 @@
-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 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$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;
-		}
-	};
-}
-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;
-		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 ?? .25,
-		dropped: trajectoryReport.dropped,
-		diagnostics: trajectoryReport.diagnostics
-	});
-	return {
-		targetPolicyId: targetPolicy.id,
-		...estimates,
-		support
-	};
-}
-function supportDiagnostics(estimate, options) {
-	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;
-}
-function isTargetProbability(value) {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
-}
-function formatProbability(value) {
-	return typeof value === "number" ? String(value) : String(value ?? "missing");
-}
-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`];
-}
-//#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,
-				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 = 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 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 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
-	};
-}
-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";
-}
-//#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$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
-	};
-}
-function selectBeliefDecisionTarget(points, options = {}) {
-	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 ?? .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));
-}
-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
-		}
-	});
-}
-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: .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: .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"
-		}
-	};
-}
-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";
-}
-function recoveryConfidence(action) {
-	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");
-}
-function outcomeFromAction(action, run) {
-	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 ?? {}
-	};
-}
-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 ?? .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) => 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;
-}
-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) {
-	return trainingScore(run) ?? null;
-}
-function sortBuckets(a, b) {
-	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 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
-	};
-}
-function corpusGate(analysis) {
-	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: []
-	};
-}
-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: []
-	};
-}
-function opeGate(analysis) {
-	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: []
-	};
-}
-function orDefault(values, fallback) {
-	return values.length > 0 ? values : [fallback];
-}
-function unique(values) {
-	return [...new Set(values)];
-}
-//#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
-	};
-}
-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);
-	}
-}
-//#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"
-];
-const BELIEF_EVIDENCE_SOURCES = [
-	"run",
-	"span",
-	"event",
-	"finding",
-	"memory",
-	"knowledge",
-	"policy"
-];
-const BELIEF_EVIDENCE_QUALITIES = [
-	"direct",
-	"derived",
-	"self-reported",
-	"unverified",
-	"stale",
-	"contradicted"
-];
-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);
-}
-function isBeliefEvidenceSource(value) {
-	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
-	};
-}
-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"),
-		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")
-	};
-}
-function stringField(obj, key) {
-	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;
-}
-function finiteUnitField(obj, key) {
-	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);
-}
-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;
-}
-function recordField(obj, key) {
-	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$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$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;
-		}
-	};
-}
-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}"`
-	});
-}
-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)
-	};
-}
-function runtimeHookEventsToEvidenceRefs(point, options) {
-	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;
-}
-function runtimeHookEventToEvidenceRef(event) {
-	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)
-	};
-}
-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
-	};
-}
-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
-	};
-}
-function mergeMetadata(base, extra) {
-	if (!base && !extra) return void 0;
-	return {
-		...base ?? {},
-		...extra ?? {}
-	};
-}
-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$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 (isRecord$1(value)) return { ...value };
-	return value;
-}
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function uniqueStrings$1(values) {
-	return [...new Set(values.filter((value) => value.length > 0))];
-}
-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;
-}
-function finiteNumberOrUndefined(value) {
-	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;
-}
-function nonNegativeNumberOrUndefined(value) {
-	const number = finiteNumberOrUndefined(value);
-	return number !== void 0 && number >= 0 ? number : void 0;
-}
-//#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,
-			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
-	};
-}
-function ratio(numerator, denominator) {
-	return denominator > 0 ? numerator / denominator : 0;
-}
-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
-];
-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
-		]
-	};
-}
-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;
-}
-function runtimeBenchmarkScenarioId(record) {
-	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;
-}
-function runtimeBenchmarkDecisionPoint(input, context) {
-	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 (!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;
-}
-function sanitizeMetadataRecord(metadata) {
-	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 (!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;
-}
-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 isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function nonEmptyString(value) {
-	return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-//#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)
-	};
-}
-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:\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 = 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)}`
-	});
-	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 ? 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;
-}
-function boundedInteger(value, min, max) {
-	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) => trimText(value, 500) ?? "").filter(Boolean);
-}
-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 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