@tangle-network/agent-eval 0.120.2 → 0.120.3

package/dist/belief-state/index.js

@@ -0,0 +1,2152 @@
+import {
+  fromClaudeCodeSession,
+  fromCodexSession,
+  fromKimiCodeSession,
+  fromOpenCodeSession,
+  fromPiSession
+} from "../chunk-HKUCJ437.js";
+import {
+  calibrationFromPairs
+} from "../chunk-NPCTHQIO.js";
+import {
+  projectRuntimeTrajectoryEvidence
+} from "../chunk-T4SQEITX.js";
+import {
+  offPolicyEstimateAll
+} from "../chunk-DTJ6QUQB.js";
+import {
+  confidenceInterval
+} from "../chunk-PJQFMIOX.js";
+import "../chunk-VI2UW6B6.js";
+import "../chunk-PXE2VKMX.js";
+import {
+  ValidationError
+} from "../chunk-ONWEPEDO.js";
+import "../chunk-PZ5AY32C.js";
+
+// 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 }
+  });
+}
+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
+function embeddedBeliefOpeTargetPolicy(id = "embedded-target-prob") {
+  return {
+    id,
+    targetProbOf(point) {
+      return point.targetProb;
+    },
+    qHatOf(point) {
+      return point.qHat;
+    }
+  };
+}
+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 qHat;
+    try {
+      targetProb = targetPolicy.targetProbOf(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;
+    }
+    if (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,
+      qHat
+    });
+  }
+  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
+  });
+  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 (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;
+}
+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(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
+};
+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,
+        qHat: point.qHat,
+        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
+  };
+}
+function acceptUtility(point, utility) {
+  return rewardOf2(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
+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";
+}
+
+// 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"
+};
+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 };
+}
+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 ?? 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;
+}
+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 };
+}
+function observedActionsFor(source, entries, options) {
+  switch (source) {
+    case "codex":
+      return codexObservedActions(entries, options);
+    case "claude-code":
+      return claudeObservedActions(entries, options);
+    case "opencode":
+      return openCodeObservedActions(entries, options);
+    case "kimi-code":
+      return kimiObservedActions(entries, options);
+    case "pi":
+      return piObservedActions(entries, options);
+  }
+}
+function codexObservedActions(entries, options) {
+  const actions = [];
+  const calls = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const payload = record(entry.payload) ?? {};
+    const entryType = stringField(entry, "type");
+    const payloadType = stringField(payload, "type");
+    const timestamp = timestampMs(entry.timestamp);
+    if (entryType === "response_item") {
+      if (payloadType === "function_call" || payloadType === "custom_tool_call") {
+        const callId = stringField(payload, "call_id") ?? stringField(payload, "id") ?? `${actions.length}`;
+        const action = observedAction({
+          options,
+          localId: callId,
+          stepIndex: actions.length,
+          kind: "tool",
+          action: stringField(payload, "name") ?? payloadType,
+          timestamp,
+          metadata: { sourceEventType: entryType, payloadType }
+        });
+        calls.set(callId, action);
+        actions.push(action);
+      }
+      if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
+        const callId = stringField(payload, "call_id") ?? stringField(payload, "id");
+        const action = callId ? calls.get(callId) : void 0;
+        if (action) action.success = !looksLikeError(payload.output);
+      }
+    }
+    if (entryType === "event_msg") {
+      if (payloadType === "patch_apply_end") {
+        actions.push(
+          observedAction({
+            options,
+            localId: stringField(payload, "call_id") ?? `patch-${actions.length}`,
+            stepIndex: actions.length,
+            kind: "patch",
+            action: "patch",
+            timestamp,
+            success: typeof payload.success === "boolean" ? payload.success : void 0,
+            metadata: { sourceEventType: entryType, payloadType }
+          })
+        );
+      }
+      if (payloadType === "task_complete" || payloadType === "turn_aborted") {
+        actions.push(
+          observedAction({
+            options,
+            localId: `${payloadType}-${actions.length}`,
+            stepIndex: actions.length,
+            kind: "terminal",
+            action: payloadType === "task_complete" ? "stop" : "abort",
+            timestamp,
+            success: payloadType === "task_complete",
+            metadata: { sourceEventType: entryType, payloadType }
+          })
+        );
+      }
+    }
+  }
+  return actions;
+}
+function claudeObservedActions(entries, options) {
+  const actions = [];
+  const calls = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const timestamp = timestampMs(entry.timestamp);
+    const message = record(entry.message);
+    const content = Array.isArray(message?.content) ? message.content : [];
+    for (const item of content) {
+      const part = record(item);
+      if (!part) continue;
+      const partType = stringField(part, "type");
+      if (partType === "tool_use") {
+        const id = stringField(part, "id") ?? `tool-${actions.length}`;
+        const action = observedAction({
+          options,
+          localId: id,
+          stepIndex: actions.length,
+          kind: "tool",
+          action: stringField(part, "name") ?? "tool",
+          timestamp,
+          metadata: { sourceEventType: stringField(entry, "type"), partType }
+        });
+        calls.set(id, action);
+        actions.push(action);
+      }
+      if (partType === "tool_result") {
+        const id = stringField(part, "tool_use_id");
+        const action = id ? calls.get(id) : void 0;
+        if (action) action.success = part.is_error !== true;
+      }
+    }
+    if (stringField(entry, "type") === "pr-link") {
+      actions.push(
+        observedAction({
+          options,
+          localId: `pr-link-${actions.length}`,
+          stepIndex: actions.length,
+          kind: "terminal",
+          action: "stop",
+          timestamp,
+          success: true,
+          metadata: { sourceEventType: "pr-link" }
+        })
+      );
+    }
+  }
+  return actions;
+}
+function openCodeObservedActions(entries, options) {
+  const actions = [];
+  for (const entry of entries) {
+    const type = stringField(entry, "type");
+    const role = stringField(entry, "role");
+    const time = record(entry.time);
+    const timestamp = timestampMs(time?.created);
+    if (type === "tool") {
+      const state = record(entry.state);
+      const status = stringField(state ?? {}, "status");
+      actions.push(
+        observedAction({
+          options,
+          localId: stringField(entry, "id") ?? `tool-${actions.length}`,
+          stepIndex: actions.length,
+          kind: "tool",
+          action: stringField(entry, "tool") ?? "tool",
+          timestamp,
+          success: status === "completed" ? true : status === "error" ? false : void 0,
+          metadata: { sourceEventType: type, status }
+        })
+      );
+    }
+    if (type === "patch") {
+      actions.push(
+        observedAction({
+          options,
+          localId: stringField(entry, "id") ?? `patch-${actions.length}`,
+          stepIndex: actions.length,
+          kind: "patch",
+          action: "patch",
+          timestamp,
+          success: true,
+          metadata: { sourceEventType: type }
+        })
+      );
+    }
+    if (role === "assistant") {
+      const finish = stringField(entry, "finish");
+      if (finish === "stop" || finish === "error") {
+        actions.push(
+          observedAction({
+            options,
+            localId: stringField(entry, "id") ?? `terminal-${actions.length}`,
+            stepIndex: actions.length,
+            kind: "terminal",
+            action: finish === "stop" ? "stop" : "abort",
+            timestamp: timestampMs(time?.completed) ?? timestamp,
+            success: finish === "stop",
+            costUsd: numberField(entry, "cost"),
+            metadata: { sourceEventType: "assistant", finish }
+          })
+        );
+      }
+    }
+  }
+  return actions;
+}
+function kimiObservedActions(entries, options) {
+  const actions = [];
+  const calls = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const timestamp = timestampMs(entry.timestamp);
+    const message = record(entry.message);
+    const messageType = stringField(message ?? {}, "type");
+    const payload = record(message?.payload) ?? {};
+    if (messageType === "ToolCall") {
+      const call = record(payload.function);
+      const id = stringField(payload, "id") ?? `tool-${actions.length}`;
+      const action = observedAction({
+        options,
+        localId: id,
+        stepIndex: actions.length,
+        kind: "tool",
+        action: stringField(call ?? {}, "name") ?? "tool",
+        timestamp,
+        metadata: { sourceEventType: messageType }
+      });
+      calls.set(id, action);
+      actions.push(action);
+    }
+    if (messageType === "ToolResult") {
+      const id = stringField(payload, "tool_call_id");
+      const action = id ? calls.get(id) : void 0;
+      if (action) action.success = record(payload.return_value)?.is_error !== true;
+    }
+    if (messageType === "TurnEnd" || messageType === "StepInterrupted") {
+      actions.push(
+        observedAction({
+          options,
+          localId: `${messageType}-${actions.length}`,
+          stepIndex: actions.length,
+          kind: "terminal",
+          action: messageType === "TurnEnd" ? "stop" : "abort",
+          timestamp,
+          success: messageType === "TurnEnd",
+          metadata: { sourceEventType: messageType }
+        })
+      );
+    }
+  }
+  return actions;
+}
+function piObservedActions(entries, options) {
+  const actions = [];
+  for (const entry of entries) {
+    const nodes = Array.isArray(entry.nodes) ? entry.nodes : [];
+    for (const node of nodes) {
+      const obj = record(node);
+      const ir = record(obj?.ir) ?? obj;
+      const kind = stringField(ir ?? {}, "kind");
+      if (kind === "ToolInvocation") {
+        actions.push(
+          observedAction({
+            options,
+            localId: stringField(ir ?? {}, "id") ?? stringField(obj ?? {}, "id") ?? `tool-${actions.length}`,
+            stepIndex: actions.length,
+            kind: "tool",
+            action: "graph-tool",
+            timestamp: timestampMs(ir?.createdAt),
+            success: void 0,
+            metadata: { sourceEventType: "graph-node", graphKind: kind }
+          })
+        );
+      }
+      if (kind === "ToolResult") {
+        const prior = [...actions].reverse().find((action) => action.kind === "tool");
+        if (prior) prior.success = true;
+      }
+      if (kind === "CompletionDecision") {
+        actions.push(
+          observedAction({
+            options,
+            localId: stringField(ir ?? {}, "id") ?? stringField(obj ?? {}, "id") ?? `completion-${actions.length}`,
+            stepIndex: actions.length,
+            kind: "graph-completion",
+            action: "complete",
+            timestamp: timestampMs(ir?.createdAt),
+            success: true,
+            metadata: { sourceEventType: "graph-node", graphKind: kind }
+          })
+        );
+      }
+    }
+  }
+  return actions;
+}
+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
+    }
+  };
+}
+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
+    }
+  };
+}
+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 0.8;
+  if (action === "retry") return 0.6;
+  if (action === "stop") return 0.55;
+  return 0.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 >= 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"
+    }
+  };
+}
+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 ?? 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 };
+}
+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
+  };
+}
+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;
+}
+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;
+}
+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 mean2(values) {
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function looksLikeError(value) {
+  if (isRecord(value)) {
+    if (value.is_error === true || value.error === true) return true;
+    if ("Err" in value) return true;
+  }
+  if (typeof value !== "string") return false;
+  return /\b(error|failed|exception|traceback)\b/i.test(value);
+}
+function timestampMs(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value > 1e12 ? value : value * 1e3;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+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 record(value) {
+  return isRecord(value) ? value : null;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// 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");
+  }
+  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 };
+}
+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") {
+    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: [] };
+}
+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)];
+}
+
+// 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 run of intake.runs) {
+      const extraction = extractCodeAgentBeliefDecisionPoints({
+        source: session.source,
+        entries: session.entries,
+        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"
+];
+var BELIEF_EVIDENCE_SOURCES = [
+  "run",
+  "span",
+  "event",
+  "finding",
+  "memory",
+  "knowledge",
+  "policy"
+];
+var 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"]
+  }
+];
+function isBeliefDecisionKind(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"]);
+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 = stringField2(payload, "kind") ?? stringField2(payload, "type");
+  if (!marker || !DECISION_MARKERS.has(marker)) return null;
+  const decisionKind = stringField2(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 = stringField2(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: stringField2(payload, "id") ?? event.eventId,
+      runId: event.runId,
+      scenarioId: stringField2(payload, "scenarioId") ?? context.scenarioId,
+      stepIndex: numberField2(payload, "stepIndex") ?? context.stepIndex,
+      kind: decisionKind,
+      chosenAction,
+      candidateActions: stringArrayField(payload, "candidateActions"),
+      confidence: finiteUnitField(payload, "confidence"),
+      behaviorProb: numberField2(payload, "behaviorProb"),
+      targetProb: numberField2(payload, "targetProb"),
+      qHat: finiteUnitField(payload, "qHat"),
+      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: stringField2(value, "observedAt"),
+    metadata: recordField(value, "metadata")
+  };
+}
+function stringField2(obj, key) {
+  const value = obj[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberField2(obj, key) {
+  const value = obj[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function finiteUnitField(obj, key) {
+  const value = numberField2(obj, key);
+  return value === void 0 ? void 0 : Math.max(0, Math.min(1, value));
+}
+function nonNegativeNumberField(obj, key) {
+  const value = numberField2(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;
+}
+
+// src/belief-state/runtime-hooks.ts
+var DEFAULT_MAX_CONTEXT_CHARS = 12e3;
+var 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
+  };
+}
+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),
+      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
+  };
+}
+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}"`
+  });
+  return void 0;
+}
+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({
+        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(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);
+  }
+}
+function snapshotUnknown(value) {
+  if (Array.isArray(value)) return [...value];
+  if (isRecord2(value)) return { ...value };
+  return value;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function uniqueStrings(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 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;
+}
+
+// src/belief-state/phase0-measurement.ts
+var 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,
+        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
+  };
+}
+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 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
+];
+var 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(record2) {
+  const parts = [
+    nonEmptyString(record2.benchmark),
+    nonEmptyString(record2.instanceId),
+    nonEmptyString(record2.condition)
+  ].filter((part) => part !== void 0);
+  return parts.length > 0 ? parts.join(":") : void 0;
+}
+function runtimeBenchmarkScenarioId(record2) {
+  return nonEmptyString(record2.instanceId);
+}
+function runtimeBenchmarkDecisionPoints(records, diagnostics) {
+  const decisions = [];
+  for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+    const record2 = records[recordIndex];
+    const raw = record2.runtimeDecisionPoints;
+    if (raw === void 0) continue;
+    const recordId = runtimeBenchmarkRecordId(record2) ?? `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)
+  };
+}
+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)
+      }
+    ];
+  });
+}
+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 (!isRecord3(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;
+}
+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 isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  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;
+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((record2) => !!record2);
+  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");
+}
+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
+  };
+}
+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
+  };
+}
+function summarizeShadowProbe(attempted, records) {
+  const confidences = records.map((record2) => record2.confidence);
+  const agreements = records.filter((record2) => record2.agreesWithObservedAction).length;
+  return {
+    attempted,
+    completed: records.length,
+    dropped: attempted - records.length,
+    withOutcome: records.filter((record2) => record2.outcome !== void 0).length,
+    withTargetProb: records.filter((record2) => record2.targetProb !== void 0).length,
+    meanConfidence: confidences.length > 0 ? mean3(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) => trimText2(value, 500) ?? "").filter(Boolean);
+}
+function uniqueStrings2(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
+};
+//# sourceMappingURL=index.js.map