@tangle-network/agent-eval 0.187.1 → 0.188.0

package/dist/experiment-tracker-URRGP9ek.d.ts

@@ -1,237 +0,0 @@
-import { p as EvidenceRef } from "./types-BjB2wZM9.js";
-//#region src/statistics/power-and-mde.d.ts
-/**
- * Required N per arm for a two-sample comparison at target effect size,
- * alpha, and power. Normal-approximation formula:
- *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2
- * where d is Cohen's d. Returns Infinity for effect ≤ 0.
- */
-declare function requiredSampleSize(opts: {
-  effect: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Required number of paired observations for a target Cohen's dz.
- * Unlike the independent-groups formula, this has no two-arm factor of two.
- *
- * Normal quantiles with no t correction, so treat the result as a LOWER bound:
- * it returns 32 where the exact t-based answer is 34 at dz = 0.5, and 13 where
- * it is 15 at dz = 0.8 — a 6–13 % shortfall precisely in the range a caller
- * consults to decide whether 3–10 repetitions suffice.
- */
-declare function requiredPairedSampleSize(opts: {
-  effect: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Minimum detectable paired effect (standardised units) for a target paired
- * sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by
- * sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap
- * have asymptotic relative efficiency below 1 vs the t-test on heavy tails.
- */
-declare function pairedMde(opts: {
-  nPaired: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Number of paired observations needed for a McNemar test to reach a target
- * power — the pre-registration companion to {@link mcnemar}. Parametrised by the
- * expected discordant-cell probabilities `p10` (P[treatment wins on a pair]) and
- * `p01` (P[control wins]); concordant pairs carry no information, so the count
- * is driven entirely by the discordant rate. Lachin's (1992) asymptotic normal
- * approximation: with discordant rate `pDisc = p10 + p01` and marginal effect
- * `δ = p10 − p01`,
- *   n = ( z_{1-α/2}·√pDisc + z_{1-β}·√(pDisc − δ²) )² / δ².
- * Returns Infinity when there is no effect (p10 === p01). Asymptotic — at the
- * tiny discordant counts where the exact {@link mcnemar} differs from the normal
- * approximation, treat the result as a lower bound and prefer the discordant-pair
- * floor.
- */
-declare function mcnemarRequiredN(opts: {
-  p10: number;
-  p01: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Power of a McNemar test at a given number of paired observations, the inverse
- * of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).
- * Returns a value in [0, 1]; equals `alpha` when there is no effect.
- */
-declare function mcnemarPower(opts: {
-  p10: number;
-  p01: number;
-  nPairs: number;
-  alpha?: number;
-  twoSided?: boolean;
-}): number;
-//#endregion
-//#region src/statistics/random.d.ts
-/** Tiny seedable PRNG (mulberry32) — deterministic resampling/shuffling, not
- *  cryptographic. Exported so e-process shuffles and bootstrap resampling
- *  share ONE PRNG implementation. Every distinct 32-bit seed gives a distinct
- *  stream, including 0. */
-declare function mulberry32(seed: number): () => number;
-//#endregion
-//#region src/experiment-tracker.d.ts
-/** Verdict for one experiment relative to its parent. ITERATE is the neutral
- *  "keep collecting reps / no parent to compare against" state. */
-type ExperimentVerdict = 'KEEP' | 'ITERATE' | 'NOISE' | 'REGRESSION';
-/** Git provenance for the working tree an experiment was run from. */
-interface ExperimentProvenance {
-  /** Commit sha (short or full — the tracker does not interpret it). */
-  commit: string;
-  /** First line of the commit message. */
-  message: string;
-  /** Files changed vs the parent commit, or a marker like 'uncommitted'. */
-  changedFiles: string[];
-}
-/** A single repetition of an experiment, carrying the score the verdict is
- *  computed on plus any free-form per-rep metrics the consumer wants kept. */
-interface ExperimentRep {
-  /** 0-indexed repetition number within the experiment. */
-  rep: number;
-  /** The score this rep is judged on (same scale as the thresholds). */
-  score: number;
-  /** ISO timestamp the rep completed. */
-  timestamp: string;
-  /** Stable execution/run identity that produced this score. */
-  runId?: string;
-  /** Mechanically resolvable trace, artifact, metric, or finding evidence. */
-  evidence?: EvidenceRef[];
-  /** Whether this rep passed the consumer's own gate — folded into `passRate`. */
-  passed?: boolean;
-  /** Free-form numeric metrics retained for later analysis. */
-  metrics?: Record<string, number>;
-}
-interface ExperimentStats {
-  median: number;
-  mean: number;
-  min: number;
-  max: number;
-  /** Inter-quartile range of the rep scores. */
-  iqr: number;
-  /** Population standard deviation of the rep scores. */
-  stddev: number;
-  /** Fraction of reps with `passed === true`, over reps that set `passed`.
-   *  null when no rep declared a pass/fail outcome. */
-  passRate: number | null;
-  /** Number of reps. */
-  n: number;
-  /** True when the sample is tight enough to trust for a verdict. */
-  stable: boolean;
-}
-interface Experiment {
-  /** Stable id for the experiment. */
-  id: string;
-  /** Free-form label / config descriptor. */
-  label: string;
-  /** Git provenance captured when the experiment was created. */
-  provenance: ExperimentProvenance;
-  /** Parent experiment id this candidate is compared against, if any. */
-  parentId?: string;
-  /** One-line summary of what changed from the parent. */
-  changeSummary: string;
-  reps: ExperimentRep[];
-  stats: ExperimentStats;
-  verdict: ExperimentVerdict;
-  /** ISO timestamp the experiment was created. */
-  createdAt: string;
-}
-interface ImprovementThresholds {
-  /** medianDelta strictly above this ⇒ KEEP. Default 5. */
-  keepThreshold?: number;
-  /** medianDelta strictly below the negative of this ⇒ REGRESSION. Default 5. */
-  regressionThreshold?: number;
-  /** iqr at or above this ⇒ unstable. Default 10. */
-  iqrUnstableAbove?: number;
-  /** stddev at or above this ⇒ unstable. Default Infinity (iqr-only stability). */
-  stddevUnstableAbove?: number;
-  /** Reps required on BOTH candidate and parent before a verdict is rendered.
-   *  Default 3. */
-  minRepsForVerdict?: number;
-}
-interface ImprovementVerdictResult {
-  verdict: ExperimentVerdict;
-  /** candidate.median − parent.median; null when no parent or insufficient reps. */
-  medianDelta: number | null;
-  /** Human-readable reason for the verdict — for dashboards and logs. */
-  reason: string;
-}
-/**
- * Compute the N-rep statistics for a set of reps. Pure — no I/O. The `stable`
- * flag is the trust gate the verdict depends on: a sample whose spread exceeds
- * the configured bounds can't distinguish a real delta from run-to-run noise.
- */
-declare function computeExperimentStats(reps: ExperimentRep[], thresholds?: ImprovementThresholds): ExperimentStats;
-/**
- * Verdict for a candidate against its parent. Pure — operates on already-computed
- * stats. KEEP/REGRESSION require both sides to have `>= minRepsForVerdict` reps
- * AND the candidate to be `stable`; otherwise the result is NOISE (unstable) or
- * ITERATE (not enough reps / no parent).
- */
-declare function improvementVerdict(candidate: ExperimentStats, parent: ExperimentStats | null, thresholds?: ImprovementThresholds): ImprovementVerdictResult;
-/** Reads git provenance for the working tree. Inject a fake in tests; the
- *  default implementation shells out to `git`. */
-type ProvenanceReader = () => ExperimentProvenance | Promise<ExperimentProvenance>;
-/** Persistence seam for the experiment log. Inject in-memory in tests; the
- *  filesystem implementation is `fileExperimentStore`. */
-interface ExperimentStore {
-  load(): Promise<Experiment[]>;
-  save(experiments: Experiment[]): Promise<void>;
-}
-/** In-memory store — the default when no persistence is wanted (tests, ephemeral
- *  runs). State lives on the instance. */
-declare function inMemoryExperimentStore(initial?: Experiment[]): ExperimentStore;
-/** Filesystem store — a single JSON array at `path`, created on first save. */
-declare function fileExperimentStore(path: string): ExperimentStore;
-interface ExperimentTrackerOptions {
-  store?: ExperimentStore;
-  provenanceReader?: ProvenanceReader;
-  thresholds?: ImprovementThresholds;
-  /** Clock seam for deterministic timestamps in tests. Default `Date.now`. */
-  now?: () => number;
-}
-interface CreateExperimentInput {
-  id: string;
-  label: string;
-  changeSummary: string;
-  parentId?: string;
-  /** Override provenance instead of reading from git (e.g. CI metadata). */
-  provenance?: ExperimentProvenance;
-}
-/**
- * Stateful tracker over an `ExperimentStore`. Create an experiment (provenance
- * is captured once), append reps as they complete (stats + verdict recompute on
- * every append), and read the log back for a dashboard. All persistence and git
- * access flow through the injected seams, so the tracker is fully testable
- * without a repo or disk.
- */
-declare class ExperimentTracker {
-  private readonly store;
-  private readonly provenanceReader;
-  private readonly thresholds;
-  private readonly now;
-  constructor(options?: ExperimentTrackerOptions);
-  create(input: CreateExperimentInput): Promise<Experiment>;
-  /** Append a rep (its `rep` index defaults to the current rep count) and
-   *  recompute stats + verdict. Returns the updated experiment. */
-  addRep(experimentId: string, rep: Omit<ExperimentRep, 'rep' | 'timestamp'> & {
-    rep?: number;
-    timestamp?: string;
-  }): Promise<Experiment>;
-  get(experimentId: string): Promise<Experiment | undefined>;
-  list(): Promise<Experiment[]>;
-  /** Full verdict (not just the enum) for an experiment vs its parent. */
-  verdictFor(experimentId: string): Promise<ImprovementVerdictResult>;
-}
-//#endregion
-export { requiredSampleSize as _, ExperimentVerdict as a, computeExperimentStats as c, inMemoryExperimentStore as d, mulberry32 as f, requiredPairedSampleSize as g, pairedMde as h, ExperimentTracker as i, fileExperimentStore as l, mcnemarRequiredN as m, ExperimentRep as n, ImprovementThresholds as o, mcnemarPower as p, ExperimentStats as r, ImprovementVerdictResult as s, Experiment as t, improvementVerdict as u };
-//# sourceMappingURL=experiment-tracker-URRGP9ek.d.ts.map

package/dist/experiment-tracker-URRGP9ek.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"experiment-tracker-URRGP9ek.d.ts","names":[],"sources":["../src/statistics/power-and-mde.ts","../src/statistics/random.ts","../src/experiment-tracker.ts"],"mappings":";;;;;;;;iBAWgB,mBAAmB;EACjC;EACA;EACA;EACA;;;;;;;;;;;iBAsBc,yBAAyB;EACvC;EACA;EACA;EACA;;;;;;;;iBAkBc,UAAU;EACxB;EACA;EACA;EACA;;;;;;;;;;;;;;;;iBAyBc,iBAAiB;EAC/B;EACA;EACA;EACA;EACA;;;;;;;iBAyBc,aAAa;EAC3B;EACA;EACA;EACA;EACA;;;;;;;;iBCrHc,WAAW;;;;;KCyBf;;UAGK;;EAEf;;EAEA;;EAEA;;;;UAKe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,WAAW;;EAEX;;EAEA,UAAU;;UAGK;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;;UAGe;;EAEf;;EAEA;;EAEA,YAAY;;EAEZ;;EAEA;EACA,MAAM;EACN,OAAO;EACP,SAAS;;EAET;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;;EAGA;;UAGe;EACf,SAAS;;EAET;;EAEA;;;;;;;iBAkDc,uBACd,MAAM,iBACN,aAAa,wBACZ;;;;;;;iBAgDa,mBACd,WAAW,iBACX,QAAQ,wBACR,aAAa,wBACZ;;;KA6CS,yBAAyB,uBAAuB,QAAQ;;;UAInD;EACf,QAAQ,QAAQ;EAChB,KAAK,aAAa,eAAe;;;;iBAoBnB,wBAAwB,UAAS,eAAoB;;iBAarD,oBAAoB,eAAe;UAyBlC;EACf,QAAQ;EACR,mBAAmB;EACnB,aAAa;;EAEb;;UAGe;EACf;EACA;EACA;EACA;;EAEA,aAAa;;;;;;;;;cAUF;mBACM;mBACA;mBACA;mBACA;EAEjB,YAAY,UAAS;EAOf,OAAO,OAAO,wBAAwB,QAAQ;;;EA6B9C,OACJ,sBACA,KAAK,KAAK;IAAwC;IAAc;MAC/D,QAAQ;EAqCL,IAAI,uBAAuB,QAAQ;EAMnC,QAAQ,QAAQ;;EAKhB,WAAW,uBAAuB,QAAQ"}

package/dist/integrity-Cy9WHAtb.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integrity-Cy9WHAtb.js","names":[],"sources":["../src/trace/integrity.ts"],"sourcesContent":["/**\n * Run-completion integrity check — at end of run, verify the expected event\n * types were actually captured. The point is the launch-review failure mode:\n * a run *appears* successful but the raw provider events were never written,\n * so a downstream reviewer can't reconstruct what happened.\n *\n * Pattern:\n *\n *   const report = await assertRunCaptured(store, runId, {\n *     llmSpansMin: 1,\n *     judgeSpansMin: 1,\n *     rawSink: providerSink,                  // must have ≥ 1 event for this run\n *     requireRawCoverageOfLlmSpans: true,     // every llm span has matching raw events\n *   })\n *   if (!report.ok) throwIfRunIncomplete(report)  // or mark run failed and continue\n *\n * The function is read-only on the store and returns a structured report;\n * the caller chooses the failure mode (throw, mark run failed, log warning).\n * `throwIfRunIncomplete` is the convenient strict mode.\n */\n\nimport { CaptureIntegrityError } from '../errors'\nimport type { RawProviderSink } from './raw-provider-sink'\nimport type { TraceStore } from './store'\n\nexport interface RunIntegrityExpectations {\n  /** Minimum LLM span count. Default 0 (no requirement). */\n  llmSpansMin?: number\n  /** Minimum judge span count. Default 0. */\n  judgeSpansMin?: number\n  /** Minimum tool span count. Default 0. */\n  toolSpansMin?: number\n  /**\n   * Raw provider sink to consult for capture verification. When present,\n   * the check requires at least one raw event for the run.\n   */\n  rawSink?: RawProviderSink\n  /** Minimum raw provider event count. Default 0; ignored when `rawSink` absent. */\n  rawProviderEventsMin?: number\n  /**\n   * Every LLM span must have at least one matching raw `request` event\n   * (matched by spanId). Catches the common bug where the structured span\n   * was emitted but the raw HTTP capture was wired to a different sink.\n   */\n  requireRawCoverageOfLlmSpans?: boolean\n  /** Run outcome must be set (not null/undefined). Default false. */\n  requireOutcome?: boolean\n}\n\nexport type RunIntegrityIssueCode =\n  | 'no_run'\n  | 'missing_llm_spans'\n  | 'missing_judge_spans'\n  | 'missing_tool_spans'\n  | 'missing_raw_events'\n  | 'no_raw_sink'\n  | 'orphan_llm_span'\n  | 'missing_outcome'\n\nexport interface RunIntegrityIssue {\n  code: RunIntegrityIssueCode\n  message: string\n  detail?: Record<string, unknown>\n}\n\nexport interface RunIntegrityReport {\n  ok: boolean\n  runId: string\n  llmSpanCount: number\n  judgeSpanCount: number\n  toolSpanCount: number\n  rawProviderEventCount: number\n  /**\n   * Coverage of LLM spans by raw provider events keyed on spanId.\n   * `total` is the number of LLM spans; `covered` is the count with at\n   * least one matching `request` raw event.\n   */\n  rawSpanCoverage: { covered: number; total: number }\n  issues: RunIntegrityIssue[]\n}\n\nexport class RunIntegrityError extends CaptureIntegrityError {\n  constructor(public readonly report: RunIntegrityReport) {\n    super(\n      `Run ${report.runId} failed integrity check: ${report.issues.map((i) => i.code).join(', ')}`,\n    )\n  }\n}\n\nexport async function assertRunCaptured(\n  store: TraceStore,\n  runId: string,\n  expectations: RunIntegrityExpectations = {},\n): Promise<RunIntegrityReport> {\n  const issues: RunIntegrityIssue[] = []\n  const run = await store.getRun(runId)\n  if (!run) {\n    return {\n      ok: false,\n      runId,\n      llmSpanCount: 0,\n      judgeSpanCount: 0,\n      toolSpanCount: 0,\n      rawProviderEventCount: 0,\n      rawSpanCoverage: { covered: 0, total: 0 },\n      issues: [{ code: 'no_run', message: `Run ${runId} not found in store.` }],\n    }\n  }\n\n  const spans = await store.spans({ runId })\n  const llmSpans = spans.filter((s) => s.kind === 'llm')\n  const judgeSpans = spans.filter((s) => s.kind === 'judge')\n  const toolSpans = spans.filter((s) => s.kind === 'tool')\n\n  const llmMin = expectations.llmSpansMin ?? 0\n  const judgeMin = expectations.judgeSpansMin ?? 0\n  const toolMin = expectations.toolSpansMin ?? 0\n\n  if (llmSpans.length < llmMin) {\n    issues.push({\n      code: 'missing_llm_spans',\n      message: `Expected ≥ ${llmMin} LLM spans, found ${llmSpans.length}.`,\n      detail: { expected: llmMin, found: llmSpans.length },\n    })\n  }\n  if (judgeSpans.length < judgeMin) {\n    issues.push({\n      code: 'missing_judge_spans',\n      message: `Expected ≥ ${judgeMin} judge spans, found ${judgeSpans.length}.`,\n      detail: { expected: judgeMin, found: judgeSpans.length },\n    })\n  }\n  if (toolSpans.length < toolMin) {\n    issues.push({\n      code: 'missing_tool_spans',\n      message: `Expected ≥ ${toolMin} tool spans, found ${toolSpans.length}.`,\n      detail: { expected: toolMin, found: toolSpans.length },\n    })\n  }\n\n  let rawEventCount = 0\n  let coverage = { covered: 0, total: llmSpans.length }\n\n  if (expectations.rawSink) {\n    if (!expectations.rawSink.list) {\n      issues.push({\n        code: 'no_raw_sink',\n        message: 'Provided rawSink does not implement list(); cannot verify capture.',\n      })\n    } else {\n      const events = await expectations.rawSink.list({ runId })\n      rawEventCount = events.length\n      const rawMin = expectations.rawProviderEventsMin ?? 1\n      if (rawEventCount < rawMin) {\n        issues.push({\n          code: 'missing_raw_events',\n          message: `Expected ≥ ${rawMin} raw provider events, found ${rawEventCount}.`,\n          detail: { expected: rawMin, found: rawEventCount },\n        })\n      }\n      if (expectations.requireRawCoverageOfLlmSpans) {\n        const requestEventsBySpan = new Set(\n          events.filter((e) => e.direction === 'request' && e.spanId).map((e) => e.spanId!),\n        )\n        const orphaned = llmSpans.filter((s) => !requestEventsBySpan.has(s.spanId))\n        coverage = { covered: llmSpans.length - orphaned.length, total: llmSpans.length }\n        if (orphaned.length > 0) {\n          issues.push({\n            code: 'orphan_llm_span',\n            message: `${orphaned.length} LLM span(s) have no matching raw provider request event.`,\n            detail: { orphanedSpanIds: orphaned.map((s) => s.spanId) },\n          })\n        }\n      }\n    }\n  } else if (expectations.requireRawCoverageOfLlmSpans || expectations.rawProviderEventsMin) {\n    issues.push({\n      code: 'no_raw_sink',\n      message: 'Raw coverage required but no rawSink supplied to the integrity check.',\n    })\n  }\n\n  if (expectations.requireOutcome && (run.outcome === undefined || run.outcome === null)) {\n    issues.push({\n      code: 'missing_outcome',\n      message: `Run ${runId} has no outcome recorded.`,\n    })\n  }\n\n  return {\n    ok: issues.length === 0,\n    runId,\n    llmSpanCount: llmSpans.length,\n    judgeSpanCount: judgeSpans.length,\n    toolSpanCount: toolSpans.length,\n    rawProviderEventCount: rawEventCount,\n    rawSpanCoverage: coverage,\n    issues,\n  }\n}\n\n/** Strict mode: throws `RunIntegrityError` when the report isn't ok. */\nexport function throwIfRunIncomplete(report: RunIntegrityReport): void {\n  if (!report.ok) throw new RunIntegrityError(report)\n}\n"],"mappings":"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"}

package/dist/integrity-rGOfSUle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"integrity-rGOfSUle.d.ts","names":[],"sources":["../src/trace/integrity.ts"],"mappings":";;;;UAyBiB;;EAEf;;EAEA;;EAEA;;;;;EAKA,UAAU;;EAEV;;;;;;EAMA;;EAEA;;KAGU;UAUK;EACf,MAAM;EACN;EACA,SAAS;;UAGM;EACf;EACA;EACA;EACA;EACA;EACA;;;;;;EAMA;IAAmB;IAAiB;;EACpC,QAAQ;;cAGG,0BAA0B;WACT,QAAQ;EAApC,YAA4B,QAAQ;;iBAOhB,kBACpB,OAAO,YACP,eACA,eAAc,2BACb,QAAQ;;iBA6GK,qBAAqB,QAAQ"}