@tangle-network/agent-eval 0.109.1 → 0.110.1

package/dist/diagnose.d.ts

@@ -1,252 +0,0 @@
-import { C as CounterfactualMutation, a as attributeCounterfactuals, b as CounterfactualRunner } from './counterfactual-DlOz8PBx.js';
-export { c as CounterfactualContext, d as CounterfactualResult } from './counterfactual-DlOz8PBx.js';
-import { S as Span } from './schema-m0gsnbt3.js';
-import { T as TraceStore } from './store-BcFXE6LG.js';
-import { a as TrajectoryStep, T as Trajectory } from './trajectory-2TkpSEVh.js';
-import { h as AnalystSeverity, A as AnalystFinding } from './types-D1ytG0Yg.js';
-import { C as CorpusRecord } from './corpus-eBVwhCp1.js';
-import { R as RunRecord } from './run-record-I-Z3JNvO.js';
-import './emitter-C2rqGH_l.js';
-import './store-C1YxJDEK.js';
-import './types-C7DGg5ex.js';
-import '@tangle-network/tcloud';
-import './llm-client-DyqEH4jH.js';
-import './errors-oeQrLqXC.js';
-import './raw-provider-sink-C46HDghv.js';
-import '@tangle-network/agent-interface';
-
-/**
- * Causal sweep — WHY did this run fail?
- *
- * Orchestrates the dormant counterfactual primitives into a responsibility
- * report: for each candidate step, run `reps` counterfactual replays per
- * mutation (via `runCounterfactual` — the consumer's `CounterfactualRunner`
- * is the execution seam) and reduce the per-rep score deltas into a mean
- * effect + bootstrap confidence interval (via `confidenceInterval`).
- *
- * Why `reps` is REQUIRED: a single intervention delta is one stochastic
- * draw — LLM re-execution from a prefix is sampled, so one replay cannot
- * distinguish "this step caused the failure" from sampling noise. The
- * signal is the distribution of deltas across reps; the CI over that
- * distribution is what lets a caller say "this step's effect excludes
- * zero" instead of eyeballing a point estimate.
- *
- * Budget discipline: the sweep never silently drops cells. When the
- * remaining budget cannot fund a full `reps`-sized cell, the sweep halts
- * and every step not fully probed is named in `uncovered`.
- */
-
-/** Stable reference to a trajectory step — carried through reports,
- *  findings, and corpus records so evidence stays addressable. */
-interface StepRef {
-    index: number;
-    spanId: string;
-    kind: Span['kind'];
-    name: string;
-}
-declare function stepRefOf(step: TrajectoryStep): StepRef;
-interface CausalSweepOptions {
-    store: TraceStore;
-    /** The failed run to diagnose. Its `outcome.score` is the baseline every
-     *  counterfactual delta is measured against. */
-    runId: string;
-    /** Execution seam — identical contract to `runCounterfactual`: re-runs the
-     *  agent from the mutation point and MUST `endRun` with a numeric score. */
-    runner: CounterfactualRunner;
-    /** Trajectory indices to probe. Default: every llm + tool span — the kinds
-     *  the existing `CounterfactualMutation` set targets. */
-    candidateSteps?: number[];
-    /**
-     * Mutations to probe a given step with. Returned mutations MUST target
-     * `step.index`. Default probes are the payload-free existing kinds:
-     *   - tool span → `swap-tool-result` with `newResult: null` (knockout:
-     *     how much did the run depend on this tool's information?)
-     *   - llm span → `truncate-after` (re-roll: how much did the realized
-     *     turn deviate from the policy's typical continuation?)
-     * `swap-model` / `inject-system-message` need consumer payloads, so they
-     * are opt-in via this callback.
-     */
-    mutationsPerStep?: (step: TrajectoryStep) => CounterfactualMutation[];
-    /** Replays per (step, mutation) cell. Minimum 2 — see module doc. */
-    reps: number;
-    /** Hard cap on total counterfactual replays across the whole sweep. */
-    budget: number;
-    /** Seed for the bootstrap CI resampler. Deterministic default so two
-     *  sweeps over the same deltas report identical intervals. */
-    ciSeed?: number;
-    /** Bootstrap CI confidence level. Default 0.95. */
-    ciConfidence?: number;
-}
-interface StepResponsibility {
-    stepRef: StepRef;
-    mutationKind: CounterfactualMutation['kind'];
-    /** Mean of per-rep score deltas (counterfactual − original). */
-    meanEffect: number;
-    /** Bootstrap CI over the per-rep deltas. */
-    ci: {
-        mean: number;
-        lower: number;
-        upper: number;
-    };
-    /** `ci.lower > 0 || ci.upper < 0` — the effect is distinguishable from noise. */
-    ciExcludesZero: boolean;
-    reps: number;
-    /** Raw per-rep deltas — downstream evidence, never re-derived. */
-    deltas: number[];
-    /** Replay run ids (layer='meta', parentRunId=original) for audit. */
-    counterfactualRunIds: string[];
-}
-interface CausalResponsibilityReport {
-    runId: string;
-    originalScore: number;
-    /** Ranked by |meanEffect| descending — the blame ordering. */
-    steps: StepResponsibility[];
-    /** Kind-level aggregate from the existing `attributeCounterfactuals`. */
-    byMutationKind: ReturnType<typeof attributeCounterfactuals>;
-    replaysUsed: number;
-    budget: number;
-    /** Steps planned but not fully probed before the budget ran out.
-     *  Named, never silent: an absent step is "no effect found"; an
-     *  uncovered step is "not measured". */
-    uncovered: StepRef[];
-}
-declare function causalSweep(opts: CausalSweepOptions): Promise<CausalResponsibilityReport>;
-
-/**
- * Replay-validated repair — WHAT SHOULD HAVE HAPPENED?
- *
- * Takes the blamed steps from a `CausalResponsibilityReport`, asks a
- * consumer-supplied `proposeFix` (LLM-backed in live use) for candidate
- * mutations, and machine-verifies each candidate by replaying the run
- * WITH the mutation applied (through the same `runCounterfactual` seam
- * the sweep uses).
- *
- * A repair is "what should have happened" ONLY when every validation
- * replay crosses `flipThreshold` — a prescription is never speculated,
- * it is demonstrated. Candidates that don't flip, or whose replay
- * errors, land in `rejected` with a typed reason; nothing is dropped
- * silently.
- */
-
-/** Context handed to `proposeFix` so an LLM-backed proposer can see the
- *  full trajectory plus the responsibility evidence for the blamed step. */
-interface RepairContext {
-    runId: string;
-    trajectory: Trajectory;
-    originalScore: number;
-    responsibility: StepResponsibility;
-}
-interface PrescribeRepairOptions {
-    store: TraceStore;
-    /** The failed run the sweep diagnosed. */
-    runId: string;
-    /** Execution seam — same `CounterfactualRunner` contract as the sweep. */
-    runner: CounterfactualRunner;
-    /** Blamed steps from `causalSweep` — typically `report.steps.slice(0, k)`. */
-    blamed: StepResponsibility[];
-    /** Candidate-fix generator. Consumer-supplied; LLM-backed in live use.
-     *  Returned mutations MUST target the blamed step's index. */
-    proposeFix: (step: TrajectoryStep, context: RepairContext) => Promise<CounterfactualMutation[]>;
-    /** Score every validation replay must reach for the repair to count. Default 0.5. */
-    flipThreshold?: number;
-    /** Validation replays per candidate mutation. Default 3. */
-    repsToValidate?: number;
-    /** Max candidate mutations tried per step. Default: all proposed. */
-    maxAttemptsPerStep?: number;
-}
-interface ValidatedRepair {
-    stepRef: StepRef;
-    mutation: CounterfactualMutation;
-    /** Always true — presence in `repairs` IS the machine-verified claim. */
-    validated: true;
-    /** Mean counterfactual score across the validation reps. */
-    meanScore: number;
-    /** meanScore − originalScore. */
-    deltaScore: number;
-    reps: number;
-    /** Replay run ids backing the validation — audit trail. */
-    counterfactualRunIds: string[];
-}
-interface RejectedRepair {
-    stepRef: StepRef;
-    mutation: CounterfactualMutation;
-    reason: 'did-not-flip' | 'error';
-    /** Present for 'did-not-flip': mean delta over the reps that ran. */
-    deltaScore?: number;
-    /** Present for 'error': the message, preserved for diagnosis. */
-    error?: string;
-}
-interface RepairReport {
-    runId: string;
-    originalScore: number;
-    flipThreshold: number;
-    repairs: ValidatedRepair[];
-    rejected: RejectedRepair[];
-    replaysUsed: number;
-}
-declare function prescribeRepair(opts: PrescribeRepairOptions): Promise<RepairReport>;
-
-/**
- * Remediation adapters — HOW DO WE MAKE IT HAPPEN?
- *
- * The diagnose chain ends by feeding existing improvement machinery,
- * not by building new machinery:
- *
- *   - `toAnalystFindings` → the analyst contract (`makeFinding`), so
- *     responsibility evidence flows into the same registry / steering /
- *     diff pipeline every other analyst feeds.
- *   - `toCorpusRecord` → the RL corpus (`CorpusRecord`), pinning the
- *     diagnosed failure + validated repair as a permanent scenario.
- *   - `suggestInvariant` → a plain-data hint in the shape the
- *     trace-contracts machinery consumes (`never` / `without` clauses).
- */
-
-declare const DIAGNOSE_ANALYST_ID = "diagnose-causal-sweep";
-/** Severity from causal effect size. Effects whose CI includes zero are
- *  'info' regardless of magnitude — an indistinguishable-from-noise effect
- *  must not steer remediation priority. */
-declare function severityFromEffect(responsibility: StepResponsibility): AnalystSeverity;
-/** Deterministic human-readable rendering of a mutation — used in
- *  recommended actions, corpus completions, and invariant hints. */
-declare function describeMutation(mutation: CounterfactualMutation): string;
-/**
- * Lift a responsibility report (and optionally its validated repairs) into
- * `AnalystFinding`s via the real `makeFinding` factory. One finding per
- * probed step; a validated repair for that step upgrades the finding with
- * a `recommended_action` + the replay-validation evidence.
- *
- * Findings are OBSERVED causal probes (replay deltas), not judge verdicts,
- * so `derived_from_judge` stays unset and they may steer.
- */
-declare function toAnalystFindings(report: CausalResponsibilityReport, repairs?: RepairReport): AnalystFinding[];
-/**
- * Pin the diagnosed failure as a permanent corpus scenario. Takes the
- * original run's `RunRecord` projection plus a validated repair and emits
- * a fresh `CorpusRecord` (new runId, so corpus dedup keeps both the raw
- * failure and the diagnosed entry).
- *
- * `completion` defaults to the validated mutation's rendering — "what
- * should have happened" in machine-derived form. Supply `prompt` (and
- * optionally a richer `completion`) when the trajectory text is available
- * so the record is harvestable by `buildDatasetFromCorpus`.
- */
-declare function toCorpusRecord(run: RunRecord, repair: ValidatedRepair, opts?: {
-    prompt?: string;
-    completion?: string;
-}): CorpusRecord;
-/** Plain-data invariant hint. The trace-contracts machinery consumes this
- *  shape: `never` is a pattern that must not appear in a passing trace;
- *  `without` is a guard whose absence makes the failure reachable. */
-interface InvariantHint {
-    description: string;
-    never?: string;
-    without?: string;
-}
-/**
- * Derive an invariant hint from a validated repair. Deterministic per
- * mutation kind — the hint names the contract a trace must satisfy so
- * the diagnosed failure cannot silently recur.
- */
-declare function suggestInvariant(repair: ValidatedRepair): InvariantHint;
-
-export { type CausalResponsibilityReport, type CausalSweepOptions, CounterfactualMutation, CounterfactualRunner, DIAGNOSE_ANALYST_ID, type InvariantHint, type PrescribeRepairOptions, type RejectedRepair, type RepairContext, type RepairReport, type StepRef, type StepResponsibility, type ValidatedRepair, causalSweep, describeMutation, prescribeRepair, severityFromEffect, stepRefOf, suggestInvariant, toAnalystFindings, toCorpusRecord };

package/dist/diagnose.js

@@ -1,382 +0,0 @@
-import {
-  attributeCounterfactuals,
-  runCounterfactual
-} from "./chunk-6SK5VFYK.js";
-import {
-  buildTrajectory
-} from "./chunk-RZTMDUO7.js";
-import {
-  makeFinding
-} from "./chunk-45EEMHTC.js";
-import {
-  confidenceInterval
-} from "./chunk-XMSYF4A7.js";
-import {
-  validateRunRecord
-} from "./chunk-VK6HBGAE.js";
-import "./chunk-TVVP3ZZQ.js";
-import "./chunk-XJYR7XFV.js";
-import "./chunk-VSMTAMNK.js";
-import {
-  ValidationError
-} from "./chunk-ONWEPEDO.js";
-import "./chunk-PZ5AY32C.js";
-
-// src/diagnose/causal-sweep.ts
-function stepRefOf(step) {
-  return {
-    index: step.index,
-    spanId: step.span.spanId,
-    kind: step.span.kind,
-    name: step.span.name
-  };
-}
-var DEFAULT_CI_SEED = 24301;
-function defaultMutations(step) {
-  if (step.span.kind === "tool") {
-    return [{ kind: "swap-tool-result", at: step.index, newResult: null }];
-  }
-  if (step.span.kind === "llm") {
-    return [{ kind: "truncate-after", at: step.index }];
-  }
-  return [];
-}
-async function causalSweep(opts) {
-  if (!Number.isInteger(opts.reps) || opts.reps < 2) {
-    throw new ValidationError(
-      `causalSweep: reps must be an integer >= 2 (got ${opts.reps}) \u2014 a single-intervention delta is one stochastic draw, not a measurement`
-    );
-  }
-  if (!Number.isInteger(opts.budget) || opts.budget < 1) {
-    throw new ValidationError(`causalSweep: budget must be an integer >= 1 (got ${opts.budget})`);
-  }
-  const originalRun = await opts.store.getRun(opts.runId);
-  if (!originalRun) throw new ValidationError(`causalSweep: run ${opts.runId} not found`);
-  const originalScore = originalRun.outcome?.score;
-  if (typeof originalScore !== "number" || !Number.isFinite(originalScore)) {
-    throw new ValidationError(
-      `causalSweep: run ${opts.runId} has no numeric outcome.score \u2014 deltas have no baseline`
-    );
-  }
-  const trajectory = await buildTrajectory(opts.store, opts.runId);
-  const candidates = resolveCandidates(trajectory, opts.candidateSteps);
-  const mutationsFor = opts.mutationsPerStep ?? defaultMutations;
-  const cells = [];
-  for (const step of candidates) {
-    const mutations = mutationsFor(step);
-    for (const m of mutations) {
-      if (m.at !== step.index) {
-        throw new ValidationError(
-          `causalSweep: mutationsPerStep returned a mutation targeting at=${m.at} for step index=${step.index} \u2014 mutations must target the step they were asked for`
-        );
-      }
-      cells.push({ step, mutation: m });
-    }
-  }
-  const responsibilities = [];
-  const allResults = [];
-  const uncoveredIndices = /* @__PURE__ */ new Set();
-  let replaysUsed = 0;
-  let halted = false;
-  for (const cell of cells) {
-    if (halted || replaysUsed + opts.reps > opts.budget) {
-      halted = true;
-      uncoveredIndices.add(cell.step.index);
-      continue;
-    }
-    const deltas = [];
-    const cfRunIds = [];
-    for (let rep = 0; rep < opts.reps; rep++) {
-      const result = await runCounterfactual(opts.store, opts.runId, cell.mutation, opts.runner);
-      replaysUsed++;
-      const d = result.delta.deltaScore;
-      if (typeof d !== "number" || !Number.isFinite(d)) {
-        throw new ValidationError(
-          `causalSweep: counterfactual replay for step ${cell.step.index} (${cell.mutation.kind}) rep ${rep} produced no numeric score \u2014 the runner must endRun with a numeric outcome.score`
-        );
-      }
-      deltas.push(d);
-      cfRunIds.push(result.counterfactualRunId);
-      allResults.push(result);
-    }
-    const ci = confidenceInterval(deltas, opts.ciConfidence ?? 0.95, {
-      seed: opts.ciSeed ?? DEFAULT_CI_SEED
-    });
-    responsibilities.push({
-      stepRef: stepRefOf(cell.step),
-      mutationKind: cell.mutation.kind,
-      meanEffect: ci.mean,
-      ci,
-      ciExcludesZero: ci.lower > 0 || ci.upper < 0,
-      reps: opts.reps,
-      deltas,
-      counterfactualRunIds: cfRunIds
-    });
-  }
-  responsibilities.sort((a, b) => Math.abs(b.meanEffect) - Math.abs(a.meanEffect));
-  const uncovered = candidates.filter((s) => uncoveredIndices.has(s.index)).map(stepRefOf);
-  return {
-    runId: opts.runId,
-    originalScore,
-    steps: responsibilities,
-    byMutationKind: attributeCounterfactuals(allResults),
-    replaysUsed,
-    budget: opts.budget,
-    uncovered
-  };
-}
-function resolveCandidates(trajectory, indices) {
-  if (indices === void 0) {
-    return trajectory.steps.filter((s) => s.span.kind === "llm" || s.span.kind === "tool");
-  }
-  return indices.map((i) => {
-    const step = trajectory.steps[i];
-    if (!step) {
-      throw new ValidationError(
-        `causalSweep: candidateSteps index ${i} out of range [0, ${trajectory.steps.length})`
-      );
-    }
-    return step;
-  });
-}
-
-// src/diagnose/remediation.ts
-var DIAGNOSE_ANALYST_ID = "diagnose-causal-sweep";
-function severityFromEffect(responsibility) {
-  if (!responsibility.ciExcludesZero) return "info";
-  const magnitude = Math.abs(responsibility.meanEffect);
-  if (magnitude >= 0.5) return "critical";
-  if (magnitude >= 0.25) return "high";
-  if (magnitude >= 0.1) return "medium";
-  return "low";
-}
-function describeMutation(mutation) {
-  switch (mutation.kind) {
-    case "swap-model":
-      return `use model '${mutation.newModel}' at step ${mutation.at}`;
-    case "swap-tool-result":
-      return `replace the tool result at step ${mutation.at} with ${JSON.stringify(mutation.newResult)}`;
-    case "truncate-after":
-      return `stop the run after step ${mutation.at}`;
-    case "inject-system-message":
-      return `inject system message at step ${mutation.at}: ${mutation.content}`;
-    case "custom":
-      return `${mutation.describe} (step ${mutation.at})`;
-  }
-}
-function toAnalystFindings(report, repairs) {
-  const repairByStep = /* @__PURE__ */ new Map();
-  for (const r of repairs?.repairs ?? []) {
-    if (!repairByStep.has(r.stepRef.spanId)) repairByStep.set(r.stepRef.spanId, r);
-  }
-  return report.steps.map((resp) => {
-    const repair = repairByStep.get(resp.stepRef.spanId);
-    const evidence = [
-      {
-        kind: "span",
-        uri: `span://${resp.stepRef.spanId}`,
-        excerpt: `step ${resp.stepRef.index} (${resp.stepRef.kind} '${resp.stepRef.name}') meanEffect=${resp.meanEffect.toFixed(4)} ci=[${resp.ci.lower.toFixed(4)}, ${resp.ci.upper.toFixed(4)}] reps=${resp.reps}`
-      },
-      {
-        kind: "metric",
-        uri: `metric://diagnose/${report.runId}/step/${resp.stepRef.index}/${resp.mutationKind}`,
-        excerpt: `deltas=[${resp.deltas.map((d) => d.toFixed(4)).join(", ")}]`
-      },
-      ...resp.counterfactualRunIds.map((id) => ({ kind: "span", uri: `run://${id}` }))
-    ];
-    return makeFinding({
-      analyst_id: DIAGNOSE_ANALYST_ID,
-      severity: severityFromEffect(resp),
-      area: "causal-attribution",
-      claim: `step '${resp.stepRef.name}' (${resp.stepRef.kind}) is causally responsible for the run outcome under ${resp.mutationKind}`,
-      rationale: resp.ciExcludesZero ? `mean effect ${resp.meanEffect.toFixed(4)} over ${resp.reps} counterfactual replays; CI [${resp.ci.lower.toFixed(4)}, ${resp.ci.upper.toFixed(4)}] excludes zero` : `mean effect ${resp.meanEffect.toFixed(4)} over ${resp.reps} counterfactual replays; CI [${resp.ci.lower.toFixed(4)}, ${resp.ci.upper.toFixed(4)}] includes zero \u2014 not distinguishable from noise`,
-      evidence_refs: evidence,
-      recommended_action: repair ? describeMutation(repair.mutation) : void 0,
-      validation_plan: repair ? `replay-validated: ${repair.reps}/${repair.reps} reps scored >= ${repairs.flipThreshold} (mean ${repair.meanScore.toFixed(4)}, delta ${repair.deltaScore.toFixed(4)})` : void 0,
-      confidence: repair ? 0.95 : resp.ciExcludesZero ? 0.85 : 0.3,
-      subject: resp.stepRef.spanId,
-      metadata: {
-        stepRef: resp.stepRef,
-        mutationKind: resp.mutationKind,
-        meanEffect: resp.meanEffect,
-        ci: resp.ci,
-        deltas: resp.deltas,
-        counterfactualRunIds: resp.counterfactualRunIds,
-        ...repair ? { repair: { mutation: repair.mutation, meanScore: repair.meanScore } } : {}
-      }
-    });
-  });
-}
-function toCorpusRecord(run, repair, opts = {}) {
-  const record = {
-    ...run,
-    runId: `${run.runId}#repair:${repair.stepRef.spanId}`,
-    outcome: {
-      ...run.outcome,
-      raw: {
-        ...run.outcome.raw,
-        diagnose_blamed_step_index: repair.stepRef.index,
-        diagnose_repair_mean_score: repair.meanScore,
-        diagnose_repair_delta_score: repair.deltaScore,
-        diagnose_repair_reps: repair.reps
-      }
-    },
-    prompt: opts.prompt,
-    completion: opts.completion ?? describeMutation(repair.mutation)
-  };
-  validateRunRecord(record);
-  return record;
-}
-function suggestInvariant(repair) {
-  const { stepRef, mutation } = repair;
-  const at = `step ${stepRef.index} (${stepRef.kind} '${stepRef.name}')`;
-  switch (mutation.kind) {
-    case "swap-tool-result":
-      return {
-        description: `the result of tool '${stepRef.name}' was causally responsible for the failure; a replaced result flipped the outcome (delta ${repair.deltaScore.toFixed(4)})`,
-        never: `unvalidated result from tool '${stepRef.name}' flows downstream`,
-        without: `result guard on tool '${stepRef.name}'`
-      };
-    case "swap-model":
-      return {
-        description: `swapping the model at ${at} to '${mutation.newModel}' flipped the outcome (delta ${repair.deltaScore.toFixed(4)})`,
-        never: `llm span '${stepRef.name}' runs on a model other than '${mutation.newModel}'`
-      };
-    case "inject-system-message":
-      return {
-        description: `injecting a system message at ${at} flipped the outcome (delta ${repair.deltaScore.toFixed(4)})`,
-        without: `system message present at '${stepRef.name}': ${mutation.content}`
-      };
-    case "truncate-after":
-      return {
-        description: `stopping after ${at} flipped the outcome (delta ${repair.deltaScore.toFixed(4)}) \u2014 continuation past this step caused the failure`,
-        never: `spans execute after '${stepRef.name}' (index ${stepRef.index})`
-      };
-    case "custom":
-      return {
-        description: `${mutation.describe} at ${at} flipped the outcome (delta ${repair.deltaScore.toFixed(4)})`
-      };
-    default: {
-      const exhausted = mutation;
-      throw new ValidationError(
-        `suggestInvariant: unknown mutation kind ${JSON.stringify(exhausted)}`
-      );
-    }
-  }
-}
-
-// src/diagnose/repair.ts
-async function prescribeRepair(opts) {
-  const flipThreshold = opts.flipThreshold ?? 0.5;
-  const repsToValidate = opts.repsToValidate ?? 3;
-  if (!Number.isInteger(repsToValidate) || repsToValidate < 1) {
-    throw new ValidationError(
-      `prescribeRepair: repsToValidate must be an integer >= 1 (got ${repsToValidate})`
-    );
-  }
-  const maxAttempts = opts.maxAttemptsPerStep ?? Number.POSITIVE_INFINITY;
-  if (maxAttempts < 1) {
-    throw new ValidationError(
-      `prescribeRepair: maxAttemptsPerStep must be >= 1 (got ${opts.maxAttemptsPerStep})`
-    );
-  }
-  if (opts.blamed.length === 0) {
-    throw new ValidationError("prescribeRepair: blamed is empty \u2014 nothing to repair");
-  }
-  const originalRun = await opts.store.getRun(opts.runId);
-  if (!originalRun) throw new ValidationError(`prescribeRepair: run ${opts.runId} not found`);
-  const originalScore = originalRun.outcome?.score;
-  if (typeof originalScore !== "number" || !Number.isFinite(originalScore)) {
-    throw new ValidationError(
-      `prescribeRepair: run ${opts.runId} has no numeric outcome.score \u2014 flips have no baseline`
-    );
-  }
-  const trajectory = await buildTrajectory(opts.store, opts.runId);
-  const repairs = [];
-  const rejected = [];
-  let replaysUsed = 0;
-  for (const responsibility of opts.blamed) {
-    const step = trajectory.steps[responsibility.stepRef.index];
-    if (!step || step.span.spanId !== responsibility.stepRef.spanId) {
-      throw new ValidationError(
-        `prescribeRepair: blamed step index=${responsibility.stepRef.index} spanId=${responsibility.stepRef.spanId} does not match run ${opts.runId} \u2014 stale report?`
-      );
-    }
-    const candidates = await opts.proposeFix(step, {
-      runId: opts.runId,
-      trajectory,
-      originalScore,
-      responsibility
-    });
-    const toTry = candidates.slice(0, maxAttempts);
-    for (const mutation of toTry) {
-      if (mutation.at !== step.index) {
-        throw new ValidationError(
-          `prescribeRepair: proposeFix returned a mutation targeting at=${mutation.at} for blamed step index=${step.index}`
-        );
-      }
-      const scores = [];
-      const cfRunIds = [];
-      let failure;
-      for (let rep = 0; rep < repsToValidate; rep++) {
-        try {
-          const result = await runCounterfactual(opts.store, opts.runId, mutation, opts.runner);
-          replaysUsed++;
-          const score = result.delta.counterfactualOutcomeScore;
-          if (typeof score !== "number" || !Number.isFinite(score)) {
-            failure = `validation rep ${rep} produced no numeric score \u2014 the runner must endRun with a numeric outcome.score`;
-            break;
-          }
-          scores.push(score);
-          cfRunIds.push(result.counterfactualRunId);
-        } catch (err) {
-          replaysUsed++;
-          failure = err instanceof Error ? err.message : String(err);
-          break;
-        }
-      }
-      if (failure !== void 0) {
-        rejected.push({
-          stepRef: responsibility.stepRef,
-          mutation,
-          reason: "error",
-          error: failure
-        });
-        continue;
-      }
-      const meanScore = scores.reduce((a, b) => a + b, 0) / scores.length;
-      const everyRepFlipped = scores.every((s) => s >= flipThreshold);
-      if (everyRepFlipped) {
-        repairs.push({
-          stepRef: responsibility.stepRef,
-          mutation,
-          validated: true,
-          meanScore,
-          deltaScore: meanScore - originalScore,
-          reps: repsToValidate,
-          counterfactualRunIds: cfRunIds
-        });
-        break;
-      }
-      rejected.push({
-        stepRef: responsibility.stepRef,
-        mutation,
-        reason: "did-not-flip",
-        deltaScore: meanScore - originalScore
-      });
-    }
-  }
-  return { runId: opts.runId, originalScore, flipThreshold, repairs, rejected, replaysUsed };
-}
-export {
-  DIAGNOSE_ANALYST_ID,
-  causalSweep,
-  describeMutation,
-  prescribeRepair,
-  severityFromEffect,
-  stepRefOf,
-  suggestInvariant,
-  toAnalystFindings,
-  toCorpusRecord
-};
-//# sourceMappingURL=diagnose.js.map