@tangle-network/agent-eval 0.221.8 → 0.222.0

package/dist/pipelines/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/pipelines/first-divergence.ts","../../src/pipelines/stuck-loop.ts"],"sourcesContent":["/**\n * Step diff between two runs, with the first divergence marked.\n *\n * Steps pair in three passes, each over the steps still unpaired:\n *   1. `id`: the same step id in both runs, e.g. a forked run that kept its\n *      parent's span ids.\n *   2. `position`: the same index with the same name and kind.\n *   3. `name`: the same name and kind anywhere, first unpaired step in order.\n * A step left unpaired exists in only one run. The first divergence is the\n * first index at which the two runs stop agreeing step for step, and it says\n * how: a paired step changed, one run replaced, added or removed a step, or the\n * runs ran the same steps in a different order.\n *\n * `diffSteps` reads plain `DiffStep` lists, so the same diff serves any step\n * source, including flat OTLP spans (`diffStepsFromSpans`). Use it to\n * attribute \"why is variant B better?\" to a step, and to compare sibling or\n * parent and child runs of a search tree.\n */\n\nimport type { DiagnosisSpan } from '../diagnosis/spans'\nimport type { TrajectoryStep } from '../trajectory'\n\n/** One step of a run, as the diff reads it. */\nexport interface DiffStep {\n  /** The step's id within its run. */\n  id: string\n  name: string\n  kind: string\n  /** Fields compared once two steps pair, such as status, tool or model. */\n  fields: Readonly<Record<string, string | number | boolean | null>>\n}\n\nexport type StepPairing = 'id' | 'position' | 'name'\n\nexport interface FieldDifference {\n  field: string\n  a: string | number | boolean | null\n  b: string | number | boolean | null\n}\n\nexport interface StepPair {\n  /** Index in run A. */\n  a: number\n  /** Index in run B. */\n  b: number\n  pairedBy: StepPairing\n  /** Empty when the paired steps agree on name, kind and every field. */\n  differences: FieldDifference[]\n}\n\nexport type StepDivergenceKind = 'changed' | 'replaced' | 'only-in-a' | 'only-in-b' | 'reordered'\n\nexport interface StepDivergence {\n  /** The first index at which the runs stop agreeing; equals `commonPrefixLen`. */\n  index: number\n  kind: StepDivergenceKind\n  /** Index of the step at `index` in each run, or null when that run has ended. */\n  a: number | null\n  b: number | null\n  /** Set when `kind` is `changed`. */\n  differences: FieldDifference[]\n  reason: string\n}\n\nexport interface StepDiff {\n  /** Paired steps in run A order. */\n  pairs: StepPair[]\n  /** Indexes of run A steps with no partner in run B. */\n  onlyInA: number[]\n  /** Indexes of run B steps with no partner in run A. */\n  onlyInB: number[]\n  /** Leading steps paired index for index with no difference. */\n  commonPrefixLen: number\n  /** Null when the runs agree step for step. */\n  firstDivergence: StepDivergence | null\n}\n\nexport function diffSteps(a: readonly DiffStep[], b: readonly DiffStep[]): StepDiff {\n  const partnerOfA = new Map<number, { b: number; pairedBy: StepPairing }>()\n  const pairedB = new Set<number>()\n  const pair = (i: number, j: number, pairedBy: StepPairing) => {\n    partnerOfA.set(i, { b: j, pairedBy })\n    pairedB.add(j)\n  }\n\n  const bById = new Map<string, number[]>()\n  b.forEach((step, j) => {\n    const list = bById.get(step.id)\n    if (list) list.push(j)\n    else bById.set(step.id, [j])\n  })\n  a.forEach((step, i) => {\n    const j = bById.get(step.id)?.find((candidate) => !pairedB.has(candidate))\n    if (j !== undefined) pair(i, j, 'id')\n  })\n  a.forEach((step, i) => {\n    if (partnerOfA.has(i) || i >= b.length || pairedB.has(i)) return\n    if (sameShape(step, b[i]!)) pair(i, i, 'position')\n  })\n  a.forEach((step, i) => {\n    if (partnerOfA.has(i)) return\n    const j = b.findIndex((candidate, index) => !pairedB.has(index) && sameShape(step, candidate))\n    if (j >= 0) pair(i, j, 'name')\n  })\n\n  const pairs: StepPair[] = [...partnerOfA.entries()]\n    .sort(([x], [y]) => x - y)\n    .map(([i, partner]) => ({\n      a: i,\n      b: partner.b,\n      pairedBy: partner.pairedBy,\n      differences: differencesBetween(a[i]!, b[partner.b]!),\n    }))\n  const pairByA = new Map(pairs.map((entry) => [entry.a, entry]))\n  const partnerOfB = new Map(pairs.map((entry) => [entry.b, entry.a]))\n\n  let prefix = 0\n  while (prefix < a.length && prefix < b.length) {\n    const entry = pairByA.get(prefix)\n    if (!entry || entry.b !== prefix || entry.differences.length > 0) break\n    prefix += 1\n  }\n\n  return {\n    pairs,\n    onlyInA: a.map((_, i) => i).filter((i) => !partnerOfA.has(i)),\n    onlyInB: b.map((_, j) => j).filter((j) => !pairedB.has(j)),\n    commonPrefixLen: prefix,\n    firstDivergence:\n      prefix === a.length && prefix === b.length\n        ? null\n        : divergenceAt(prefix, a, b, pairByA.get(prefix), partnerOfB),\n  }\n}\n\nfunction divergenceAt(\n  index: number,\n  a: readonly DiffStep[],\n  b: readonly DiffStep[],\n  pairOfA: StepPair | undefined,\n  partnerOfB: ReadonlyMap<number, number>,\n): StepDivergence {\n  const stepA = a[index]\n  const stepB = b[index]\n  const base = {\n    index,\n    a: stepA ? index : null,\n    b: stepB ? index : null,\n    differences: [] as FieldDifference[],\n  }\n  if (stepA && stepB && pairOfA?.b === index) {\n    return {\n      ...base,\n      kind: 'changed',\n      differences: pairOfA.differences,\n      reason: `at index ${index}, ${describe(stepA)} changed: ${pairOfA.differences\n        .map((d) => `${d.field} ${String(d.a)} vs ${String(d.b)}`)\n        .join('; ')}`,\n    }\n  }\n  const aUnpaired = stepA !== undefined && pairOfA === undefined\n  const bUnpaired = stepB !== undefined && !partnerOfB.has(index)\n  if (stepA && stepB && aUnpaired && bUnpaired) {\n    return {\n      ...base,\n      kind: 'replaced',\n      reason: `at index ${index}, A ran ${describe(stepA)} and B ran ${describe(stepB)}`,\n    }\n  }\n  if (stepA && aUnpaired) {\n    return {\n      ...base,\n      kind: 'only-in-a',\n      reason: `at index ${index}, only A has ${describe(stepA)}`,\n    }\n  }\n  if (stepB && bUnpaired) {\n    return {\n      ...base,\n      kind: 'only-in-b',\n      reason: `at index ${index}, only B has ${describe(stepB)}`,\n    }\n  }\n  return {\n    ...base,\n    kind: 'reordered',\n    reason: `at index ${index}, A ran ${describe(stepA!)} and B ran ${describe(stepB!)}; both steps occur in the other run at a different position`,\n  }\n}\n\nfunction sameShape(x: DiffStep, y: DiffStep): boolean {\n  return x.name === y.name && x.kind === y.kind\n}\n\nfunction differencesBetween(x: DiffStep, y: DiffStep): FieldDifference[] {\n  const differences: FieldDifference[] = []\n  if (x.kind !== y.kind) differences.push({ field: 'kind', a: x.kind, b: y.kind })\n  if (x.name !== y.name) differences.push({ field: 'name', a: x.name, b: y.name })\n  const fields = [...new Set([...Object.keys(x.fields), ...Object.keys(y.fields)])].sort()\n  for (const field of fields) {\n    const left = x.fields[field] ?? null\n    const right = y.fields[field] ?? null\n    if (left !== right) differences.push({ field, a: left, b: right })\n  }\n  return differences\n}\n\nfunction describe(step: DiffStep): string {\n  return `${step.kind} \"${step.name}\"`\n}\n\n// ── agent-eval trace store ────────────────────────────────────────────\n\nexport interface DivergenceReport {\n  runA: string\n  runB: string\n  /** Null when the runs agree step for step. */\n  firstDivergenceIndex: number | null\n  aStep?: TrajectoryStep\n  bStep?: TrajectoryStep\n  reason?: string\n  commonPrefixLen: number\n  /** The step diff behind the first divergence, over trajectory step indexes. */\n  diff: StepDiff\n}\n\n// ── flat OTLP spans ───────────────────────────────────────────────────\n\n/**\n * One run's spans as diff steps, in containment order: depth first, siblings\n * by start time, the same order `buildTrajectory` gives a trace store run.\n * Spans whose parent is absent, or whose parents form a cycle, start their own\n * subtree, so every span appears exactly once.\n */\nexport function diffStepsFromSpans(spans: readonly DiagnosisSpan[]): DiffStep[] {\n  const ids = new Set(spans.map((span) => span.spanId))\n  const children = new Map<string | null, DiagnosisSpan[]>()\n  for (const span of spans) {\n    const parent =\n      span.parentSpanId !== null && ids.has(span.parentSpanId) ? span.parentSpanId : null\n    const list = children.get(parent)\n    if (list) list.push(span)\n    else children.set(parent, [span])\n  }\n  // Span ids are random per run, so two runs of the same logical trace can carry\n  // different ids for \"the same\" span. Siblings that share a start time (a common\n  // case: parallel steps a driver starts together) must still sort the same way\n  // in both runs, or the diff below reports a false `reordered` divergence purely\n  // from spanId noise. End time, kind and name are content, not per-run identity,\n  // so they break the tie before spanId, which is the last resort.\n  const byStart = (x: DiagnosisSpan, y: DiagnosisSpan) =>\n    (x.startMs ?? 0) - (y.startMs ?? 0) ||\n    (x.endMs ?? 0) - (y.endMs ?? 0) ||\n    x.kind.localeCompare(y.kind) ||\n    x.name.localeCompare(y.name) ||\n    x.spanId.localeCompare(y.spanId)\n  for (const list of children.values()) list.sort(byStart)\n  const ordered: DiffStep[] = []\n  const visited = new Set<string>()\n  const visit = (span: DiagnosisSpan) => {\n    if (visited.has(span.spanId)) return\n    visited.add(span.spanId)\n    ordered.push({\n      id: span.spanId,\n      name: span.name,\n      kind: span.kind,\n      fields: { status: span.status, tool: span.toolName, model: span.model },\n    })\n    for (const child of children.get(span.spanId) ?? []) visit(child)\n  }\n  for (const root of children.get(null) ?? []) visit(root)\n  for (const span of [...spans].sort(byStart)) visit(span)\n  return ordered\n}\n","/**\n * StuckLoopView — detects when an agent calls the same tool with the\n * same (or structurally similar) arguments ≥ N times in a short window.\n *\n * Rationale: agents that loop are the number-one production failure\n * mode on long-horizon flows. The view returns (runId, toolName,\n * argHash, occurrences, windowMs) for each detected loop plus a\n * fraction of runs affected.\n */\n\nimport { executionTrackByLane } from '../trace/execution-tracks'\nimport { argHash, hasCapturedToolArgs } from '../trace/query'\nimport { isToolSpan, type Span, type ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\n\nconst DEFAULT_MAX_WINDOW_MS = 60_000\nconst DEFAULT_MAX_INTERVENING_TOOL_CALLS = 0\n\ninterface ScopedToolCall {\n  span: ToolSpan\n  scopeSpanId: string | null\n  laneSpanId: string | null\n}\n\ninterface IndexedToolCall extends ScopedToolCall {\n  toolCallIndex: number\n  trackId: string\n}\n\nexport interface StuckLoopFinding {\n  runId: string\n  toolName: string\n  argHash: string\n  /** Calls in this episode's densest qualifying interval, not the whole-run total. */\n  occurrences: number\n  spanIds: string[]\n  /** Nearest agent ancestor, or the direct parent when ancestry is incomplete. */\n  scopeSpanId?: string\n  /** Milliseconds between first and last call in the loop. */\n  windowMs: number\n}\n\nexport interface StuckLoopReport {\n  findings: StuckLoopFinding[]\n  affectedRunRatio: number\n  totalRuns: number\n}\n\nexport interface StuckLoopOptions {\n  /** Minimum call count to flag a loop (default 3). */\n  minOccurrences?: number\n  /** Maximum time between the first and last repeated call (default 60 seconds). */\n  maxWindowMs?: number\n  /**\n   * Maximum other tool calls allowed between adjacent repeats (default 0).\n   * Set to 1 to detect alternating patterns such as A,B,A,B,A.\n   */\n  maxInterveningToolCalls?: number\n  /** Filter to a specific runId; omit to scan the entire corpus. */\n  runId?: string\n}\n\nexport async function stuckLoopView(\n  store: TraceStore,\n  options: StuckLoopOptions = {},\n): Promise<StuckLoopReport> {\n  const minOccurrences = options.minOccurrences ?? 3\n  const maxWindowMs = options.maxWindowMs ?? DEFAULT_MAX_WINDOW_MS\n  const maxInterveningToolCalls =\n    options.maxInterveningToolCalls ?? DEFAULT_MAX_INTERVENING_TOOL_CALLS\n  if (!Number.isInteger(minOccurrences) || minOccurrences < 1) {\n    throw new RangeError('minOccurrences must be a positive integer')\n  }\n  if (!Number.isFinite(maxWindowMs) || maxWindowMs < 0) {\n    throw new RangeError('maxWindowMs must be a finite non-negative number')\n  }\n  if (!Number.isInteger(maxInterveningToolCalls) || maxInterveningToolCalls < 0) {\n    throw new RangeError('maxInterveningToolCalls must be a non-negative integer')\n  }\n  const runs = options.runId\n    ? [{ runId: options.runId }]\n    : (await store.listRuns()).map((r) => ({ runId: r.runId }))\n\n  const findings: StuckLoopFinding[] = []\n  for (const { runId } of runs) {\n    const spans = await store.spans({ runId })\n    const spansById = new Map(spans.map((span) => [span.spanId, span]))\n    const scopedTools: ScopedToolCall[] = spans\n      .filter(isToolSpan)\n      .map((span, sourceIndex) => ({ span, sourceIndex }))\n      .sort((a, b) => a.span.startedAt - b.span.startedAt || a.sourceIndex - b.sourceIndex)\n      .map(({ span }) => ({ span, ...executionScope(span, spansById) }))\n    const trackByLane = executionTrackByLane(\n      scopedTools.map((call) => {\n        const direct = call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n        const timed = direct\n          ? call.span\n          : call.laneSpanId\n            ? spansById.get(call.laneSpanId)\n            : undefined\n        return {\n          key: executionKey(call),\n          scopeKey: JSON.stringify(call.scopeSpanId),\n          start: timed?.startedAt ?? null,\n          end: timed?.endedAt ?? null,\n        }\n      }),\n    )\n    const nextToolIndexByTrack = new Map<string, number>()\n    const orderedTools: IndexedToolCall[] = scopedTools.map((call) => {\n      const trackId = trackByLane.get(executionKey(call))!\n      const toolCallIndex = nextToolIndexByTrack.get(trackId) ?? 0\n      nextToolIndexByTrack.set(trackId, toolCallIndex + 1)\n      return { ...call, toolCallIndex, trackId }\n    })\n    const byKey = new Map<\n      string,\n      {\n        calls: IndexedToolCall[]\n        argHash: string\n        toolName: string\n        scopeSpanId: string | null\n      }\n    >()\n    for (const call of orderedTools) {\n      if (!hasCapturedToolArgs(call.span)) continue\n      const h = argHash(call.span.args)\n      const key = JSON.stringify([call.trackId, call.span.toolName, h])\n      const bucket = byKey.get(key) ?? {\n        calls: [],\n        argHash: h,\n        toolName: call.span.toolName,\n        scopeSpanId: call.scopeSpanId,\n      }\n      bucket.calls.push(call)\n      byKey.set(key, bucket)\n    }\n    for (const { calls, argHash: h, toolName, scopeSpanId } of byKey.values()) {\n      if (calls.length < minOccurrences) continue\n      let episodeStart = 0\n      for (let episodeEnd = 1; episodeEnd <= calls.length; episodeEnd += 1) {\n        const previous = calls[episodeEnd - 1]!\n        const next = calls[episodeEnd]\n        const episodeEnded =\n          next === undefined ||\n          next.span.startedAt - previous.span.startedAt > maxWindowMs ||\n          next.toolCallIndex - previous.toolCallIndex - 1 > maxInterveningToolCalls ||\n          !callsAreSerial(previous, next)\n        if (!episodeEnded) continue\n\n        const episode = calls.slice(episodeStart, episodeEnd)\n        let left = 0\n        let bestStart = 0\n        let bestEnd = -1\n        for (let right = 0; right < episode.length; right += 1) {\n          while (episode[right]!.span.startedAt - episode[left]!.span.startedAt > maxWindowMs) {\n            left += 1\n          }\n          if (right - left > bestEnd - bestStart) {\n            bestStart = left\n            bestEnd = right\n          }\n        }\n        if (bestEnd - bestStart + 1 >= minOccurrences) {\n          const loop = episode.slice(bestStart, bestEnd + 1)\n          const first = loop[0]!.span.startedAt\n          const last = loop[loop.length - 1]!.span.startedAt\n          findings.push({\n            runId,\n            toolName,\n            argHash: h,\n            occurrences: loop.length,\n            spanIds: loop.map((call) => call.span.spanId),\n            ...(scopeSpanId ? { scopeSpanId } : {}),\n            windowMs: last - first,\n          })\n        }\n        episodeStart = episodeEnd\n      }\n    }\n  }\n\n  const affectedRuns = new Set(findings.map((f) => f.runId))\n  return {\n    findings,\n    affectedRunRatio: runs.length > 0 ? affectedRuns.size / runs.length : 0,\n    totalRuns: runs.length,\n  }\n}\n\nfunction laneKey(call: Pick<ScopedToolCall, 'scopeSpanId' | 'laneSpanId'>): string {\n  return JSON.stringify([call.scopeSpanId, call.laneSpanId])\n}\n\nfunction executionKey(call: ScopedToolCall): string {\n  return call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n    ? JSON.stringify([call.scopeSpanId, call.span.spanId])\n    : laneKey(call)\n}\n\nfunction executionScope(\n  span: ToolSpan,\n  spansById: ReadonlyMap<string, Span>,\n): { scopeSpanId: string | null; laneSpanId: string | null } {\n  const directParent = span.parentSpanId\n  if (!directParent) return { scopeSpanId: null, laneSpanId: null }\n\n  let currentId: string | undefined = directParent\n  let laneSpanId: string | null = null\n  const seen = new Set<string>()\n  while (currentId && !seen.has(currentId)) {\n    seen.add(currentId)\n    const current = spansById.get(currentId)\n    if (!current) return { scopeSpanId: directParent, laneSpanId: directParent }\n    if (current.kind === 'agent') {\n      return { scopeSpanId: current.spanId, laneSpanId: laneSpanId ?? current.spanId }\n    }\n    laneSpanId = current.spanId\n    currentId = current.parentSpanId\n  }\n  return { scopeSpanId: directParent, laneSpanId: directParent }\n}\n\nfunction callsAreSerial(previous: IndexedToolCall, next: IndexedToolCall): boolean {\n  return previous.span.endedAt !== undefined && previous.span.endedAt <= next.span.startedAt\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/pipelines/first-divergence.ts","../../src/pipelines/stuck-loop.ts"],"sourcesContent":["/**\n * Step diff between two runs, with the first divergence marked.\n *\n * Steps pair in three passes, each over the steps still unpaired:\n *   1. `id`: the same step id in both runs, e.g. a forked run that kept its\n *      parent's span ids.\n *   2. `position`: the same index with the same name and kind.\n *   3. `name`: the same name and kind anywhere, first unpaired step in order.\n * A step left unpaired exists in only one run. The first divergence is the\n * first index at which the two runs stop agreeing step for step, and it says\n * how: a paired step changed, one run replaced, added or removed a step, or the\n * runs ran the same steps in a different order.\n *\n * `diffSteps` reads plain `DiffStep` lists, so the same diff serves any step\n * source, including flat OTLP spans (`diffStepsFromSpans`). Use it to\n * attribute \"why is variant B better?\" to a step, and to compare sibling or\n * parent and child runs of a search tree.\n */\n\nimport type { DiagnosisSpan } from '../diagnosis/spans'\nimport type { TrajectoryStep } from '../trajectory'\n\n/** One step of a run, as the diff reads it. */\nexport interface DiffStep {\n  /** The step's id within its run. */\n  id: string\n  name: string\n  kind: string\n  /** Fields compared once two steps pair, such as status, tool or model. */\n  fields: Readonly<Record<string, string | number | boolean | null>>\n}\n\nexport type StepPairing = 'id' | 'position' | 'name'\n\nexport interface FieldDifference {\n  field: string\n  a: string | number | boolean | null\n  b: string | number | boolean | null\n}\n\nexport interface StepPair {\n  /** Index in run A. */\n  a: number\n  /** Index in run B. */\n  b: number\n  pairedBy: StepPairing\n  /** Empty when the paired steps agree on name, kind and every field. */\n  differences: FieldDifference[]\n}\n\nexport type StepDivergenceKind = 'changed' | 'replaced' | 'only-in-a' | 'only-in-b' | 'reordered'\n\nexport interface StepDivergence {\n  /** The first index at which the runs stop agreeing; equals `commonPrefixLen`. */\n  index: number\n  kind: StepDivergenceKind\n  /** Index of the step at `index` in each run, or null when that run has ended. */\n  a: number | null\n  b: number | null\n  /** Set when `kind` is `changed`. */\n  differences: FieldDifference[]\n  reason: string\n}\n\nexport interface StepDiff {\n  /** Paired steps in run A order. */\n  pairs: StepPair[]\n  /** Indexes of run A steps with no partner in run B. */\n  onlyInA: number[]\n  /** Indexes of run B steps with no partner in run A. */\n  onlyInB: number[]\n  /** Leading steps paired index for index with no difference. */\n  commonPrefixLen: number\n  /** Null when the runs agree step for step. */\n  firstDivergence: StepDivergence | null\n}\n\nexport function diffSteps(a: readonly DiffStep[], b: readonly DiffStep[]): StepDiff {\n  const partnerOfA = new Map<number, { b: number; pairedBy: StepPairing }>()\n  const pairedB = new Set<number>()\n  const pair = (i: number, j: number, pairedBy: StepPairing) => {\n    partnerOfA.set(i, { b: j, pairedBy })\n    pairedB.add(j)\n  }\n\n  const bById = new Map<string, number[]>()\n  b.forEach((step, j) => {\n    const list = bById.get(step.id)\n    if (list) list.push(j)\n    else bById.set(step.id, [j])\n  })\n  a.forEach((step, i) => {\n    const j = bById.get(step.id)?.find((candidate) => !pairedB.has(candidate))\n    if (j !== undefined) pair(i, j, 'id')\n  })\n  a.forEach((step, i) => {\n    if (partnerOfA.has(i) || i >= b.length || pairedB.has(i)) return\n    if (sameShape(step, b[i]!)) pair(i, i, 'position')\n  })\n  a.forEach((step, i) => {\n    if (partnerOfA.has(i)) return\n    const j = b.findIndex((candidate, index) => !pairedB.has(index) && sameShape(step, candidate))\n    if (j >= 0) pair(i, j, 'name')\n  })\n\n  const pairs: StepPair[] = [...partnerOfA.entries()]\n    .sort(([x], [y]) => x - y)\n    .map(([i, partner]) => ({\n      a: i,\n      b: partner.b,\n      pairedBy: partner.pairedBy,\n      differences: differencesBetween(a[i]!, b[partner.b]!),\n    }))\n  const pairByA = new Map(pairs.map((entry) => [entry.a, entry]))\n  const partnerOfB = new Map(pairs.map((entry) => [entry.b, entry.a]))\n\n  let prefix = 0\n  while (prefix < a.length && prefix < b.length) {\n    const entry = pairByA.get(prefix)\n    if (!entry || entry.b !== prefix || entry.differences.length > 0) break\n    prefix += 1\n  }\n\n  return {\n    pairs,\n    onlyInA: a.map((_, i) => i).filter((i) => !partnerOfA.has(i)),\n    onlyInB: b.map((_, j) => j).filter((j) => !pairedB.has(j)),\n    commonPrefixLen: prefix,\n    firstDivergence:\n      prefix === a.length && prefix === b.length\n        ? null\n        : divergenceAt(prefix, a, b, pairByA.get(prefix), partnerOfB),\n  }\n}\n\nfunction divergenceAt(\n  index: number,\n  a: readonly DiffStep[],\n  b: readonly DiffStep[],\n  pairOfA: StepPair | undefined,\n  partnerOfB: ReadonlyMap<number, number>,\n): StepDivergence {\n  const stepA = a[index]\n  const stepB = b[index]\n  const base = {\n    index,\n    a: stepA ? index : null,\n    b: stepB ? index : null,\n    differences: [] as FieldDifference[],\n  }\n  if (stepA && stepB && pairOfA?.b === index) {\n    return {\n      ...base,\n      kind: 'changed',\n      differences: pairOfA.differences,\n      reason: `at index ${index}, ${describe(stepA)} changed: ${pairOfA.differences\n        .map((d) => `${d.field} ${String(d.a)} vs ${String(d.b)}`)\n        .join('; ')}`,\n    }\n  }\n  const aUnpaired = stepA !== undefined && pairOfA === undefined\n  const bUnpaired = stepB !== undefined && !partnerOfB.has(index)\n  if (stepA && stepB && aUnpaired && bUnpaired) {\n    return {\n      ...base,\n      kind: 'replaced',\n      reason: `at index ${index}, A ran ${describe(stepA)} and B ran ${describe(stepB)}`,\n    }\n  }\n  if (stepA && aUnpaired) {\n    return {\n      ...base,\n      kind: 'only-in-a',\n      reason: `at index ${index}, only A has ${describe(stepA)}`,\n    }\n  }\n  if (stepB && bUnpaired) {\n    return {\n      ...base,\n      kind: 'only-in-b',\n      reason: `at index ${index}, only B has ${describe(stepB)}`,\n    }\n  }\n  return {\n    ...base,\n    kind: 'reordered',\n    reason: `at index ${index}, A ran ${describe(stepA!)} and B ran ${describe(stepB!)}; both steps occur in the other run at a different position`,\n  }\n}\n\nfunction sameShape(x: DiffStep, y: DiffStep): boolean {\n  return x.name === y.name && x.kind === y.kind\n}\n\nfunction differencesBetween(x: DiffStep, y: DiffStep): FieldDifference[] {\n  const differences: FieldDifference[] = []\n  if (x.kind !== y.kind) differences.push({ field: 'kind', a: x.kind, b: y.kind })\n  if (x.name !== y.name) differences.push({ field: 'name', a: x.name, b: y.name })\n  const fields = [...new Set([...Object.keys(x.fields), ...Object.keys(y.fields)])].sort()\n  for (const field of fields) {\n    const left = x.fields[field] ?? null\n    const right = y.fields[field] ?? null\n    if (left !== right) differences.push({ field, a: left, b: right })\n  }\n  return differences\n}\n\nfunction describe(step: DiffStep): string {\n  return `${step.kind} \"${step.name}\"`\n}\n\n// ── agent-eval trace store ────────────────────────────────────────────\n\nexport interface DivergenceReport {\n  runA: string\n  runB: string\n  /** Null when the runs agree step for step. */\n  firstDivergenceIndex: number | null\n  aStep?: TrajectoryStep\n  bStep?: TrajectoryStep\n  reason?: string\n  commonPrefixLen: number\n  /** The step diff behind the first divergence, over trajectory step indexes. */\n  diff: StepDiff\n}\n\n// ── flat OTLP spans ───────────────────────────────────────────────────\n\n/**\n * One run's spans as diff steps, in containment order: depth first, siblings\n * by start time, the same order `buildTrajectory` gives a trace store run.\n * Spans whose parent is absent, or whose parents form a cycle, start their own\n * subtree, so every span appears exactly once.\n */\nexport function diffStepsFromSpans(spans: readonly DiagnosisSpan[]): DiffStep[] {\n  const ids = new Set(spans.map((span) => span.spanId))\n  const children = new Map<string | null, DiagnosisSpan[]>()\n  for (const span of spans) {\n    const parent =\n      span.parentSpanId !== null && ids.has(span.parentSpanId) ? span.parentSpanId : null\n    const list = children.get(parent)\n    if (list) list.push(span)\n    else children.set(parent, [span])\n  }\n  // Span ids are random per run, so two runs of the same logical trace can carry\n  // different ids for \"the same\" span. Siblings that share a start time (a common\n  // case: parallel steps a driver starts together) must still sort the same way\n  // in both runs, or the diff below reports a false `reordered` divergence purely\n  // from spanId noise. End time, kind and name are content, not per-run identity,\n  // so they break the tie before spanId, which is the last resort.\n  const byStart = (x: DiagnosisSpan, y: DiagnosisSpan) =>\n    (x.startMs ?? 0) - (y.startMs ?? 0) ||\n    (x.endMs ?? 0) - (y.endMs ?? 0) ||\n    x.kind.localeCompare(y.kind) ||\n    x.name.localeCompare(y.name) ||\n    x.spanId.localeCompare(y.spanId)\n  for (const list of children.values()) list.sort(byStart)\n  const ordered: DiffStep[] = []\n  const visited = new Set<string>()\n  const visit = (span: DiagnosisSpan) => {\n    if (visited.has(span.spanId)) return\n    visited.add(span.spanId)\n    ordered.push({\n      id: span.spanId,\n      name: span.name,\n      kind: span.kind,\n      fields: { status: span.status, tool: span.toolName, model: span.model },\n    })\n    for (const child of children.get(span.spanId) ?? []) visit(child)\n  }\n  for (const root of children.get(null) ?? []) visit(root)\n  for (const span of [...spans].sort(byStart)) visit(span)\n  return ordered\n}\n","/**\n * StuckLoopView — detects when an agent calls the same tool with the\n * same (or structurally similar) arguments ≥ N times in a short window.\n *\n * Rationale: agents that loop are the number-one production failure\n * mode on long-horizon flows. The view returns (runId, toolName,\n * argHash, occurrences, windowMs) for each detected loop plus a\n * fraction of runs affected.\n */\n\nimport { executionTrackByLane } from '../trace/execution-tracks'\nimport { argHash, hasCapturedToolArgs } from '../trace/query'\nimport { isToolSpan, type Span, type ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\n\nconst DEFAULT_MAX_WINDOW_MS = 60_000\nconst DEFAULT_MAX_INTERVENING_TOOL_CALLS = 0\n\ninterface ScopedToolCall {\n  span: ToolSpan\n  scopeSpanId: string | null\n  laneSpanId: string | null\n}\n\ninterface IndexedToolCall extends ScopedToolCall {\n  toolCallIndex: number\n  trackId: string\n}\n\nexport interface StuckLoopFinding {\n  runId: string\n  toolName: string\n  argHash: string\n  /** Calls in this episode's densest qualifying interval, not the whole-run total. */\n  occurrences: number\n  spanIds: string[]\n  /** Nearest agent ancestor, or the direct parent when ancestry is incomplete. */\n  scopeSpanId?: string\n  /** Milliseconds between first and last call in the loop. */\n  windowMs: number\n}\n\nexport interface StuckLoopReport {\n  findings: StuckLoopFinding[]\n  affectedRunRatio: number\n  totalRuns: number\n}\n\nexport interface StuckLoopOptions {\n  /** Minimum call count to flag a loop (default 3). */\n  minOccurrences?: number\n  /** Maximum time between the first and last repeated call (default 60 seconds). */\n  maxWindowMs?: number\n  /**\n   * Maximum other tool calls allowed between adjacent repeats (default 0).\n   * Set to 1 to detect alternating patterns such as A,B,A,B,A.\n   */\n  maxInterveningToolCalls?: number\n  /** Filter to a specific runId; omit to scan the entire corpus. */\n  runId?: string\n}\n\nexport async function stuckLoopView(\n  store: TraceStore,\n  options: StuckLoopOptions = {},\n): Promise<StuckLoopReport> {\n  const minOccurrences = options.minOccurrences ?? 3\n  const maxWindowMs = options.maxWindowMs ?? DEFAULT_MAX_WINDOW_MS\n  const maxInterveningToolCalls =\n    options.maxInterveningToolCalls ?? DEFAULT_MAX_INTERVENING_TOOL_CALLS\n  if (!Number.isInteger(minOccurrences) || minOccurrences < 1) {\n    throw new RangeError('minOccurrences must be a positive integer')\n  }\n  if (!Number.isFinite(maxWindowMs) || maxWindowMs < 0) {\n    throw new RangeError('maxWindowMs must be a finite non-negative number')\n  }\n  if (!Number.isInteger(maxInterveningToolCalls) || maxInterveningToolCalls < 0) {\n    throw new RangeError('maxInterveningToolCalls must be a non-negative integer')\n  }\n  const runs = options.runId\n    ? [{ runId: options.runId }]\n    : (await store.listRuns()).map((r) => ({ runId: r.runId }))\n\n  const findings: StuckLoopFinding[] = []\n  for (const { runId } of runs) {\n    const spans = await store.spans({ runId })\n    const spansById = new Map(spans.map((span) => [span.spanId, span]))\n    const scopedTools: ScopedToolCall[] = spans\n      .filter(isToolSpan)\n      .map((span, sourceIndex) => ({ span, sourceIndex }))\n      .sort((a, b) => a.span.startedAt - b.span.startedAt || a.sourceIndex - b.sourceIndex)\n      .map(({ span }) => ({ span, ...executionScope(span, spansById) }))\n    const trackByLane = executionTrackByLane(\n      scopedTools.map((call) => {\n        const direct = call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n        const timed = direct\n          ? call.span\n          : call.laneSpanId\n            ? spansById.get(call.laneSpanId)\n            : undefined\n        return {\n          key: executionKey(call),\n          scopeKey: JSON.stringify(call.scopeSpanId),\n          start: timed?.startedAt ?? null,\n          end: timed?.endedAt ?? null,\n        }\n      }),\n    )\n    const nextToolIndexByTrack = new Map<string, number>()\n    const orderedTools: IndexedToolCall[] = scopedTools.map((call) => {\n      const trackId = trackByLane.get(executionKey(call))!\n      const toolCallIndex = nextToolIndexByTrack.get(trackId) ?? 0\n      nextToolIndexByTrack.set(trackId, toolCallIndex + 1)\n      return { ...call, toolCallIndex, trackId }\n    })\n    const byKey = new Map<\n      string,\n      {\n        calls: IndexedToolCall[]\n        argHash: string\n        toolName: string\n        scopeSpanId: string | null\n      }\n    >()\n    for (const call of orderedTools) {\n      if (!hasCapturedToolArgs(call.span)) continue\n      const h = argHash(call.span.args)\n      const key = JSON.stringify([call.trackId, call.span.toolName, h])\n      const bucket = byKey.get(key) ?? {\n        calls: [],\n        argHash: h,\n        toolName: call.span.toolName,\n        scopeSpanId: call.scopeSpanId,\n      }\n      bucket.calls.push(call)\n      byKey.set(key, bucket)\n    }\n    for (const { calls, argHash: h, toolName, scopeSpanId } of byKey.values()) {\n      if (calls.length < minOccurrences) continue\n      let episodeStart = 0\n      for (let episodeEnd = 1; episodeEnd <= calls.length; episodeEnd += 1) {\n        const previous = calls[episodeEnd - 1]!\n        const next = calls[episodeEnd]\n        const episodeEnded =\n          next === undefined ||\n          next.span.startedAt - previous.span.startedAt > maxWindowMs ||\n          next.toolCallIndex - previous.toolCallIndex - 1 > maxInterveningToolCalls ||\n          !callsAreSerial(previous, next)\n        if (!episodeEnded) continue\n\n        const episode = calls.slice(episodeStart, episodeEnd)\n        let left = 0\n        let bestStart = 0\n        let bestEnd = -1\n        for (let right = 0; right < episode.length; right += 1) {\n          while (episode[right]!.span.startedAt - episode[left]!.span.startedAt > maxWindowMs) {\n            left += 1\n          }\n          if (right - left > bestEnd - bestStart) {\n            bestStart = left\n            bestEnd = right\n          }\n        }\n        if (bestEnd - bestStart + 1 >= minOccurrences) {\n          const loop = episode.slice(bestStart, bestEnd + 1)\n          const first = loop[0]!.span.startedAt\n          const last = loop[loop.length - 1]!.span.startedAt\n          findings.push({\n            runId,\n            toolName,\n            argHash: h,\n            occurrences: loop.length,\n            spanIds: loop.map((call) => call.span.spanId),\n            ...(scopeSpanId ? { scopeSpanId } : {}),\n            windowMs: last - first,\n          })\n        }\n        episodeStart = episodeEnd\n      }\n    }\n  }\n\n  const affectedRuns = new Set(findings.map((f) => f.runId))\n  return {\n    findings,\n    affectedRunRatio: runs.length > 0 ? affectedRuns.size / runs.length : 0,\n    totalRuns: runs.length,\n  }\n}\n\nfunction laneKey(call: Pick<ScopedToolCall, 'scopeSpanId' | 'laneSpanId'>): string {\n  return JSON.stringify([call.scopeSpanId, call.laneSpanId])\n}\n\nfunction executionKey(call: ScopedToolCall): string {\n  return call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n    ? JSON.stringify([call.scopeSpanId, call.span.spanId])\n    : laneKey(call)\n}\n\nfunction executionScope(\n  span: ToolSpan,\n  spansById: ReadonlyMap<string, Span>,\n): { scopeSpanId: string | null; laneSpanId: string | null } {\n  const directParent = span.parentSpanId\n  if (!directParent) return { scopeSpanId: null, laneSpanId: null }\n\n  let currentId: string | undefined = directParent\n  let laneSpanId: string | null = null\n  const seen = new Set<string>()\n  while (currentId && !seen.has(currentId)) {\n    seen.add(currentId)\n    const current = spansById.get(currentId)\n    if (!current) return { scopeSpanId: directParent, laneSpanId: directParent }\n    if (current.kind === 'agent') {\n      return { scopeSpanId: current.spanId, laneSpanId: laneSpanId ?? current.spanId }\n    }\n    laneSpanId = current.spanId\n    currentId = current.parentSpanId\n  }\n  return { scopeSpanId: directParent, laneSpanId: directParent }\n}\n\nfunction callsAreSerial(previous: IndexedToolCall, next: IndexedToolCall): boolean {\n  return previous.span.endedAt !== undefined && previous.span.endedAt <= next.span.startedAt\n}\n"],"mappings":"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"}

package/dist/{power-and-mde-CQX-0weG.js → power-and-mde-ClI6RWw4.js}

@@ -1,6 +1,6 @@
-import { o as normalCdf } from "./paired-arms-B2ttLc0_.js";
-import { s as zQuantile } from "./internal-BTK91Bqt.js";
-//#region src/statistics/power-and-mde.ts
+import { o as normalCdf } from "./paired-arms-D-54hO-k.js";
+import { s as zQuantile } from "./internal-v6XfOeJW.js";
+// src/statistics/power-and-mde.ts
 /**
 * Required N per arm for a two-sample comparison at target effect size,
 * alpha, and power. Normal-approximation formula:
@@ -94,7 +94,6 @@ function mcnemarPower(opts) {
 	const zBeta = (Math.sqrt(nPairs) * Math.abs(delta) - zAlpha * Math.sqrt(pDisc)) / denom;
 	return Math.min(1, Math.max(0, normalCdf(zBeta)));
 }
-//#endregion
 export { requiredSampleSize as a, requiredPairedSampleSize as i, mcnemarRequiredN as n, pairedMde as r, mcnemarPower as t };
 
-//# sourceMappingURL=power-and-mde-CQX-0weG.js.map
+//# sourceMappingURL=power-and-mde-ClI6RWw4.js.map

package/dist/{power-and-mde-CQX-0weG.js.map → power-and-mde-ClI6RWw4.js.map}

@@ -1 +1 @@
-{"version":3,"file":"power-and-mde-CQX-0weG.js","names":[],"sources":["../src/statistics/power-and-mde.ts"],"sourcesContent":["import { normalCdf } from '../math/normal'\nimport { zQuantile } from './internal'\n\n// ── Power analysis + minimum detectable effect ───────────────────────\n\n/**\n * Required N per arm for a two-sample comparison at target effect size,\n * alpha, and power. Normal-approximation formula:\n *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2\n * where d is Cohen's d. Returns Infinity for effect ≤ 0.\n */\nexport function requiredSampleSize(opts: {\n  effect: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const effect = opts.effect\n  if (!Number.isFinite(effect) || effect <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  const n = 2 * ((zAlpha + zBeta) / effect) ** 2\n  return Math.ceil(n)\n}\n\n/**\n * Required number of paired observations for a target Cohen's dz.\n * Unlike the independent-groups formula, this has no two-arm factor of two.\n *\n * Normal quantiles with no t correction, so treat the result as a LOWER bound:\n * it returns 32 where the exact t-based answer is 34 at dz = 0.5, and 13 where\n * it is 15 at dz = 0.8 — a 6–13 % shortfall precisely in the range a caller\n * consults to decide whether 3–10 repetitions suffice.\n */\nexport function requiredPairedSampleSize(opts: {\n  effect: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const effect = opts.effect\n  if (!Number.isFinite(effect) || effect <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  return Math.ceil(((zAlpha + zBeta) / effect) ** 2)\n}\n\n/**\n * Minimum detectable paired effect (standardised units) for a target paired\n * sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by\n * sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap\n * have asymptotic relative efficiency below 1 vs the t-test on heavy tails.\n */\nexport function pairedMde(opts: {\n  nPaired: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  if (!Number.isFinite(opts.nPaired) || opts.nPaired <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  return (zAlpha + zBeta) / Math.sqrt(opts.nPaired)\n}\n\n/**\n * Number of paired observations needed for a McNemar test to reach a target\n * power — the pre-registration companion to {@link mcnemar}. Parametrised by the\n * expected discordant-cell probabilities `p10` (P[treatment wins on a pair]) and\n * `p01` (P[control wins]); concordant pairs carry no information, so the count\n * is driven entirely by the discordant rate. Lachin's (1992) asymptotic normal\n * approximation: with discordant rate `pDisc = p10 + p01` and marginal effect\n * `δ = p10 − p01`,\n *   n = ( z_{1-α/2}·√pDisc + z_{1-β}·√(pDisc − δ²) )² / δ².\n * Returns Infinity when there is no effect (p10 === p01). Asymptotic — at the\n * tiny discordant counts where the exact {@link mcnemar} differs from the normal\n * approximation, treat the result as a lower bound and prefer the discordant-pair\n * floor.\n */\nexport function mcnemarRequiredN(opts: {\n  p10: number\n  p01: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const { p10, p01 } = opts\n  if (p10 < 0 || p01 < 0 || p10 + p01 > 1) {\n    throw new Error(`mcnemarRequiredN: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`)\n  }\n  const delta = p10 - p01\n  if (delta === 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const pDisc = p10 + p01\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  const n =\n    (zAlpha * Math.sqrt(pDisc) + zBeta * Math.sqrt(Math.max(0, pDisc - delta * delta))) ** 2 /\n    (delta * delta)\n  return Math.ceil(n)\n}\n\n/**\n * Power of a McNemar test at a given number of paired observations, the inverse\n * of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).\n * Returns a value in [0, 1]; equals `alpha` when there is no effect.\n */\nexport function mcnemarPower(opts: {\n  p10: number\n  p01: number\n  nPairs: number\n  alpha?: number\n  twoSided?: boolean\n}): number {\n  const { p10, p01, nPairs } = opts\n  if (p10 < 0 || p01 < 0 || p10 + p01 > 1) {\n    throw new Error(`mcnemarPower: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`)\n  }\n  const alpha = opts.alpha ?? 0.05\n  const twoSided = opts.twoSided ?? true\n  const delta = p10 - p01\n  if (delta === 0 || nPairs <= 0) return alpha\n  const pDisc = p10 + p01\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const denom = Math.sqrt(Math.max(1e-12, pDisc - delta * delta))\n  const zBeta = (Math.sqrt(nPairs) * Math.abs(delta) - zAlpha * Math.sqrt(pDisc)) / denom\n  return Math.min(1, Math.max(0, normalCdf(zBeta)))\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,mBAAmB,MAKxB;CACT,MAAM,SAAS,KAAK;CACpB,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GAAG,OAAO;CACpD,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAGlC,MAAM,IAAI,MAFK,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAEnC,IADP,UAAU,KACK,KAAK,WAAW;CAC7C,OAAO,KAAK,KAAK,CAAC;AACpB;;;;;;;;;;AAWA,SAAgB,yBAAyB,MAK9B;CACT,MAAM,SAAS,KAAK;CACpB,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GAAG,OAAO;CACpD,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,UAAU,KAAK;CAC7B,OAAO,KAAK,OAAO,SAAS,SAAS,WAAW,CAAC;AACnD;;;;;;;AAQA,SAAgB,UAAU,MAKf;CACT,IAAI,CAAC,OAAO,SAAS,KAAK,OAAO,KAAK,KAAK,WAAW,GAAG,OAAO;CAChE,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAGlC,QAFe,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAE3C,IADC,UAAU,KACH,KAAK,KAAK,KAAK,KAAK,OAAO;AAClD;;;;;;;;;;;;;;;AAgBA,SAAgB,iBAAiB,MAMtB;CACT,MAAM,EAAE,KAAK,QAAQ;CACrB,IAAI,MAAM,KAAK,MAAM,KAAK,MAAM,MAAM,GACpC,MAAM,IAAI,MAAM,8DAA8D,IAAI,IAAI,IAAI,EAAE;CAE9F,MAAM,QAAQ,MAAM;CACpB,IAAI,UAAU,GAAG,OAAO;CACxB,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,UAAU,KAAK;CAC7B,MAAM,KACH,SAAS,KAAK,KAAK,KAAK,IAAI,QAAQ,KAAK,KAAK,KAAK,IAAI,GAAG,QAAQ,QAAQ,KAAK,CAAC,MAAM,KACtF,QAAQ;CACX,OAAO,KAAK,KAAK,CAAC;AACpB;;;;;;AAOA,SAAgB,aAAa,MAMlB;CACT,MAAM,EAAE,KAAK,KAAK,WAAW;CAC7B,IAAI,MAAM,KAAK,MAAM,KAAK,MAAM,MAAM,GACpC,MAAM,IAAI,MAAM,0DAA0D,IAAI,IAAI,IAAI,EAAE;CAE1F,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,QAAQ,MAAM;CACpB,IAAI,UAAU,KAAK,UAAU,GAAG,OAAO;CACvC,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,KAAK,KAAK,KAAK,IAAI,OAAO,QAAQ,QAAQ,KAAK,CAAC;CAC9D,MAAM,SAAS,KAAK,KAAK,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,SAAS,KAAK,KAAK,KAAK,KAAK;CAClF,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,UAAU,KAAK,CAAC,CAAC;AAClD"}
+{"version":3,"file":"power-and-mde-ClI6RWw4.js","names":[],"sources":["../src/statistics/power-and-mde.ts"],"sourcesContent":["import { normalCdf } from '../math/normal'\nimport { zQuantile } from './internal'\n\n// ── Power analysis + minimum detectable effect ───────────────────────\n\n/**\n * Required N per arm for a two-sample comparison at target effect size,\n * alpha, and power. Normal-approximation formula:\n *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2\n * where d is Cohen's d. Returns Infinity for effect ≤ 0.\n */\nexport function requiredSampleSize(opts: {\n  effect: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const effect = opts.effect\n  if (!Number.isFinite(effect) || effect <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  const n = 2 * ((zAlpha + zBeta) / effect) ** 2\n  return Math.ceil(n)\n}\n\n/**\n * Required number of paired observations for a target Cohen's dz.\n * Unlike the independent-groups formula, this has no two-arm factor of two.\n *\n * Normal quantiles with no t correction, so treat the result as a LOWER bound:\n * it returns 32 where the exact t-based answer is 34 at dz = 0.5, and 13 where\n * it is 15 at dz = 0.8 — a 6–13 % shortfall precisely in the range a caller\n * consults to decide whether 3–10 repetitions suffice.\n */\nexport function requiredPairedSampleSize(opts: {\n  effect: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const effect = opts.effect\n  if (!Number.isFinite(effect) || effect <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  return Math.ceil(((zAlpha + zBeta) / effect) ** 2)\n}\n\n/**\n * Minimum detectable paired effect (standardised units) for a target paired\n * sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by\n * sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap\n * have asymptotic relative efficiency below 1 vs the t-test on heavy tails.\n */\nexport function pairedMde(opts: {\n  nPaired: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  if (!Number.isFinite(opts.nPaired) || opts.nPaired <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  return (zAlpha + zBeta) / Math.sqrt(opts.nPaired)\n}\n\n/**\n * Number of paired observations needed for a McNemar test to reach a target\n * power — the pre-registration companion to {@link mcnemar}. Parametrised by the\n * expected discordant-cell probabilities `p10` (P[treatment wins on a pair]) and\n * `p01` (P[control wins]); concordant pairs carry no information, so the count\n * is driven entirely by the discordant rate. Lachin's (1992) asymptotic normal\n * approximation: with discordant rate `pDisc = p10 + p01` and marginal effect\n * `δ = p10 − p01`,\n *   n = ( z_{1-α/2}·√pDisc + z_{1-β}·√(pDisc − δ²) )² / δ².\n * Returns Infinity when there is no effect (p10 === p01). Asymptotic — at the\n * tiny discordant counts where the exact {@link mcnemar} differs from the normal\n * approximation, treat the result as a lower bound and prefer the discordant-pair\n * floor.\n */\nexport function mcnemarRequiredN(opts: {\n  p10: number\n  p01: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const { p10, p01 } = opts\n  if (p10 < 0 || p01 < 0 || p10 + p01 > 1) {\n    throw new Error(`mcnemarRequiredN: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`)\n  }\n  const delta = p10 - p01\n  if (delta === 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const pDisc = p10 + p01\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  const n =\n    (zAlpha * Math.sqrt(pDisc) + zBeta * Math.sqrt(Math.max(0, pDisc - delta * delta))) ** 2 /\n    (delta * delta)\n  return Math.ceil(n)\n}\n\n/**\n * Power of a McNemar test at a given number of paired observations, the inverse\n * of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).\n * Returns a value in [0, 1]; equals `alpha` when there is no effect.\n */\nexport function mcnemarPower(opts: {\n  p10: number\n  p01: number\n  nPairs: number\n  alpha?: number\n  twoSided?: boolean\n}): number {\n  const { p10, p01, nPairs } = opts\n  if (p10 < 0 || p01 < 0 || p10 + p01 > 1) {\n    throw new Error(`mcnemarPower: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`)\n  }\n  const alpha = opts.alpha ?? 0.05\n  const twoSided = opts.twoSided ?? true\n  const delta = p10 - p01\n  if (delta === 0 || nPairs <= 0) return alpha\n  const pDisc = p10 + p01\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const denom = Math.sqrt(Math.max(1e-12, pDisc - delta * delta))\n  const zBeta = (Math.sqrt(nPairs) * Math.abs(delta) - zAlpha * Math.sqrt(pDisc)) / denom\n  return Math.min(1, Math.max(0, normalCdf(zBeta)))\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,mBAAmB,MAKxB;CACT,MAAM,SAAS,KAAK;CACpB,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GAAG,OAAO;CACpD,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAGlC,MAAM,IAAI,MAFK,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAEnC,IADP,UAAU,KACK,KAAK,WAAW;CAC7C,OAAO,KAAK,KAAK,CAAC;AACpB;;;;;;;;;;AAWA,SAAgB,yBAAyB,MAK9B;CACT,MAAM,SAAS,KAAK;CACpB,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GAAG,OAAO;CACpD,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,UAAU,KAAK;CAC7B,OAAO,KAAK,OAAO,SAAS,SAAS,WAAW,CAAC;AACnD;;;;;;;AAQA,SAAgB,UAAU,MAKf;CACT,IAAI,CAAC,OAAO,SAAS,KAAK,OAAO,KAAK,KAAK,WAAW,GAAG,OAAO;CAChE,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAGlC,QAFe,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAE3C,IADC,UAAU,KACH,KAAK,KAAK,KAAK,KAAK,OAAO;AAClD;;;;;;;;;;;;;;;AAgBA,SAAgB,iBAAiB,MAMtB;CACT,MAAM,EAAE,KAAK,QAAQ;CACrB,IAAI,MAAM,KAAK,MAAM,KAAK,MAAM,MAAM,GACpC,MAAM,IAAI,MAAM,8DAA8D,IAAI,IAAI,IAAI,EAAE;CAE9F,MAAM,QAAQ,MAAM;CACpB,IAAI,UAAU,GAAG,OAAO;CACxB,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,UAAU,KAAK;CAC7B,MAAM,KACH,SAAS,KAAK,KAAK,KAAK,IAAI,QAAQ,KAAK,KAAK,KAAK,IAAI,GAAG,QAAQ,QAAQ,KAAK,CAAC,MAAM,KACtF,QAAQ;CACX,OAAO,KAAK,KAAK,CAAC;AACpB;;;;;;AAOA,SAAgB,aAAa,MAMlB;CACT,MAAM,EAAE,KAAK,KAAK,WAAW;CAC7B,IAAI,MAAM,KAAK,MAAM,KAAK,MAAM,MAAM,GACpC,MAAM,IAAI,MAAM,0DAA0D,IAAI,IAAI,IAAI,EAAE;CAE1F,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,QAAQ,MAAM;CACpB,IAAI,UAAU,KAAK,UAAU,GAAG,OAAO;CACvC,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,KAAK,KAAK,KAAK,IAAI,OAAO,QAAQ,QAAQ,KAAK,CAAC;CAC9D,MAAM,SAAS,KAAK,KAAK,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,SAAS,KAAK,KAAK,KAAK,KAAK;CAClF,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,UAAU,KAAK,CAAC,CAAC;AAClD"}

package/dist/{predicate-FdKmElA_.js → predicate-BYHA4MBn.js}

@@ -1,4 +1,4 @@
-//#region src/experiment/ast/predicate.ts
+// src/experiment/ast/predicate.ts
 /** Read a dot-separated field path. Missing segments yield `undefined`. */
 function readField(record, path) {
 	let current = record;
@@ -32,7 +32,6 @@ function compareValues(value, op, target) {
 		case "gte": return left >= right;
 	}
 }
-//#endregion
 export { evaluatePredicate as n, readField as r, compareValues as t };
 
-//# sourceMappingURL=predicate-FdKmElA_.js.map
+//# sourceMappingURL=predicate-BYHA4MBn.js.map

package/dist/{predicate-FdKmElA_.js.map → predicate-BYHA4MBn.js.map}

@@ -1 +1 @@
-{"version":3,"file":"predicate-FdKmElA_.js","names":[],"sources":["../src/experiment/ast/predicate.ts"],"sourcesContent":["import type { EvidenceRecord, JsonValue } from './evidence'\n\n// ── Predicate ────────────────────────────────────────────────────────\n\n/**\n * Closed-key comparison over a declared record schema. The only leaf node.\n * `field` is a dot-separated path into an evidence record.\n */\nexport type Predicate =\n  | {\n      kind: 'compare'\n      field: string\n      op: 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte'\n      value: JsonValue\n    }\n  | { kind: 'in'; field: string; values: JsonValue[] }\n  | { kind: 'all'; of: Predicate[] }\n  | { kind: 'any'; of: Predicate[] }\n  | { kind: 'not'; of: Predicate }\n\n/** Read a dot-separated field path. Missing segments yield `undefined`. */\nexport function readField(record: EvidenceRecord, path: string): unknown {\n  let current: unknown = record\n  for (const key of path.split('.')) {\n    if (current === null || typeof current !== 'object') return undefined\n    current = (current as Record<string, unknown>)[key]\n  }\n  return current\n}\n\n/** Evaluate a predicate against one evidence record. */\nexport function evaluatePredicate(predicate: Predicate, record: EvidenceRecord): boolean {\n  switch (predicate.kind) {\n    case 'compare':\n      return compareValues(readField(record, predicate.field), predicate.op, predicate.value)\n    case 'in':\n      return predicate.values.includes(readField(record, predicate.field) as JsonValue)\n    case 'all':\n      return predicate.of.every((p) => evaluatePredicate(p, record))\n    case 'any':\n      return predicate.of.some((p) => evaluatePredicate(p, record))\n    case 'not':\n      return !evaluatePredicate(predicate.of, record)\n  }\n}\n\n/** Numbers compare numerically; everything else compares as strings. */\nexport function compareValues(\n  value: unknown,\n  op: 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte',\n  target: JsonValue,\n): boolean {\n  if (op === 'eq') return value === target\n  if (op === 'ne') return value !== target\n  const numeric = typeof value === 'number' && typeof target === 'number'\n  const left = numeric ? (value as number) : String(value)\n  const right = numeric ? (target as number) : String(target)\n  switch (op) {\n    case 'lt':\n      return left < right\n    case 'lte':\n      return left <= right\n    case 'gt':\n      return left > right\n    case 'gte':\n      return left >= right\n  }\n}\n"],"mappings":";;AAqBA,SAAgB,UAAU,QAAwB,MAAuB;CACvE,IAAI,UAAmB;CACvB,KAAK,MAAM,OAAO,KAAK,MAAM,GAAG,GAAG;EACjC,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU,OAAO,KAAA;EAC5D,UAAW,QAAoC;CACjD;CACA,OAAO;AACT;;AAGA,SAAgB,kBAAkB,WAAsB,QAAiC;CACvF,QAAQ,UAAU,MAAlB;EACE,KAAK,WACH,OAAO,cAAc,UAAU,QAAQ,UAAU,KAAK,GAAG,UAAU,IAAI,UAAU,KAAK;EACxF,KAAK,MACH,OAAO,UAAU,OAAO,SAAS,UAAU,QAAQ,UAAU,KAAK,CAAc;EAClF,KAAK,OACH,OAAO,UAAU,GAAG,OAAO,MAAM,kBAAkB,GAAG,MAAM,CAAC;EAC/D,KAAK,OACH,OAAO,UAAU,GAAG,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC;EAC9D,KAAK,OACH,OAAO,CAAC,kBAAkB,UAAU,IAAI,MAAM;CAClD;AACF;;AAGA,SAAgB,cACd,OACA,IACA,QACS;CACT,IAAI,OAAO,MAAM,OAAO,UAAU;CAClC,IAAI,OAAO,MAAM,OAAO,UAAU;CAClC,MAAM,UAAU,OAAO,UAAU,YAAY,OAAO,WAAW;CAC/D,MAAM,OAAO,UAAW,QAAmB,OAAO,KAAK;CACvD,MAAM,QAAQ,UAAW,SAAoB,OAAO,MAAM;CAC1D,QAAQ,IAAR;EACE,KAAK,MACH,OAAO,OAAO;EAChB,KAAK,OACH,OAAO,QAAQ;EACjB,KAAK,MACH,OAAO,OAAO;EAChB,KAAK,OACH,OAAO,QAAQ;CACnB;AACF"}
+{"version":3,"file":"predicate-BYHA4MBn.js","names":[],"sources":["../src/experiment/ast/predicate.ts"],"sourcesContent":["import type { EvidenceRecord, JsonValue } from './evidence'\n\n// ── Predicate ────────────────────────────────────────────────────────\n\n/**\n * Closed-key comparison over a declared record schema. The only leaf node.\n * `field` is a dot-separated path into an evidence record.\n */\nexport type Predicate =\n  | {\n      kind: 'compare'\n      field: string\n      op: 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte'\n      value: JsonValue\n    }\n  | { kind: 'in'; field: string; values: JsonValue[] }\n  | { kind: 'all'; of: Predicate[] }\n  | { kind: 'any'; of: Predicate[] }\n  | { kind: 'not'; of: Predicate }\n\n/** Read a dot-separated field path. Missing segments yield `undefined`. */\nexport function readField(record: EvidenceRecord, path: string): unknown {\n  let current: unknown = record\n  for (const key of path.split('.')) {\n    if (current === null || typeof current !== 'object') return undefined\n    current = (current as Record<string, unknown>)[key]\n  }\n  return current\n}\n\n/** Evaluate a predicate against one evidence record. */\nexport function evaluatePredicate(predicate: Predicate, record: EvidenceRecord): boolean {\n  switch (predicate.kind) {\n    case 'compare':\n      return compareValues(readField(record, predicate.field), predicate.op, predicate.value)\n    case 'in':\n      return predicate.values.includes(readField(record, predicate.field) as JsonValue)\n    case 'all':\n      return predicate.of.every((p) => evaluatePredicate(p, record))\n    case 'any':\n      return predicate.of.some((p) => evaluatePredicate(p, record))\n    case 'not':\n      return !evaluatePredicate(predicate.of, record)\n  }\n}\n\n/** Numbers compare numerically; everything else compares as strings. */\nexport function compareValues(\n  value: unknown,\n  op: 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte',\n  target: JsonValue,\n): boolean {\n  if (op === 'eq') return value === target\n  if (op === 'ne') return value !== target\n  const numeric = typeof value === 'number' && typeof target === 'number'\n  const left = numeric ? (value as number) : String(value)\n  const right = numeric ? (target as number) : String(target)\n  switch (op) {\n    case 'lt':\n      return left < right\n    case 'lte':\n      return left <= right\n    case 'gt':\n      return left > right\n    case 'gte':\n      return left >= right\n  }\n}\n"],"mappings":";;AAqBA,SAAgB,UAAU,QAAwB,MAAuB;CACvE,IAAI,UAAmB;CACvB,KAAK,MAAM,OAAO,KAAK,MAAM,GAAG,GAAG;EACjC,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU,OAAO,KAAA;EAC5D,UAAW,QAAoC;CACjD;CACA,OAAO;AACT;;AAGA,SAAgB,kBAAkB,WAAsB,QAAiC;CACvF,QAAQ,UAAU,MAAlB;EACE,KAAK,WACH,OAAO,cAAc,UAAU,QAAQ,UAAU,KAAK,GAAG,UAAU,IAAI,UAAU,KAAK;EACxF,KAAK,MACH,OAAO,UAAU,OAAO,SAAS,UAAU,QAAQ,UAAU,KAAK,CAAc;EAClF,KAAK,OACH,OAAO,UAAU,GAAG,OAAO,MAAM,kBAAkB,GAAG,MAAM,CAAC;EAC/D,KAAK,OACH,OAAO,UAAU,GAAG,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC;EAC9D,KAAK,OACH,OAAO,CAAC,kBAAkB,UAAU,IAAI,MAAM;CAClD;AACF;;AAGA,SAAgB,cACd,OACA,IACA,QACS;CACT,IAAI,OAAO,MAAM,OAAO,UAAU;CAClC,IAAI,OAAO,MAAM,OAAO,UAAU;CAClC,MAAM,UAAU,OAAO,UAAU,YAAY,OAAO,WAAW;CAC/D,MAAM,OAAO,UAAW,QAAmB,OAAO,KAAK;CACvD,MAAM,QAAQ,UAAW,SAAoB,OAAO,MAAM;CAC1D,QAAQ,IAAR;EACE,KAAK,MACH,OAAO,OAAO;EAChB,KAAK,OACH,OAAO,QAAQ;EACjB,KAAK,MACH,OAAO,OAAO;EAChB,KAAK,OACH,OAAO,QAAQ;CACnB;AACF"}

package/dist/{prime-bridge-transport-6feEglLf.d.ts → prime-bridge-transport-Cfqir_Im.d.ts}

@@ -1,4 +1,3 @@
-//#region src/analyst/prime-bridge-transport.d.ts
 /**
  * The bridge seam for the prime analyst protocol: one POST to an
  * OpenAI-compatible `/v1/chat/completions` endpoint, returning the raw status
@@ -44,6 +43,5 @@ type PrimeBridgeTransport = (request: PrimeBridgeTransportRequest) => Promise<Pr
  * minutes, so the request's AbortSignal is the only deadline.
  */
 declare function nodeHttpPrimeBridgeTransport(): PrimeBridgeTransport;
-//#endregion
 export { nodeHttpPrimeBridgeTransport as i, PrimeBridgeTransportRequest as n, PrimeBridgeTransportResult as r, PrimeBridgeTransport as t };
-//# sourceMappingURL=prime-bridge-transport-6feEglLf.d.ts.map
+//# sourceMappingURL=prime-bridge-transport-Cfqir_Im.d.ts.map

package/dist/prime-bridge-transport-Cfqir_Im.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prime-bridge-transport-Cfqir_Im.d.ts","names":[],"sources":["../src/analyst/prime-bridge-transport.ts"],"mappings":";;;;;;;;;;;;;;;;;UAoBiB;EACf;EACA;IACE;IACA,UAAU;MAAQ;MAAc;;;;;;;;EAOlC,QAAQ;;UAGO;EACf;EACA;;;KAIU,wBACV,SAAS,gCACN,QAAQ;;;;;;iBAOG,gCAAgC"}

package/dist/{prime-bridge-transport-Z3cpKGoV.js → prime-bridge-transport-Csd5SQg7.js}

@@ -1,6 +1,6 @@
 import { request } from "node:http";
 import { request as request$1 } from "node:https";
-//#region src/analyst/prime-bridge-transport.ts
+// src/analyst/prime-bridge-transport.ts
 /**
 * Default transport on node:http/node:https rather than fetch: undici's fixed
 * response-header timeout kills prime calls that legitimately run past five
@@ -37,7 +37,6 @@ function nodeHttpPrimeBridgeTransport() {
 		});
 	};
 }
-//#endregion
 export { nodeHttpPrimeBridgeTransport as t };
 
-//# sourceMappingURL=prime-bridge-transport-Z3cpKGoV.js.map
+//# sourceMappingURL=prime-bridge-transport-Csd5SQg7.js.map

package/dist/{prime-bridge-transport-Z3cpKGoV.js.map → prime-bridge-transport-Csd5SQg7.js.map}

@@ -1 +1 @@
-{"version":3,"file":"prime-bridge-transport-Z3cpKGoV.js","names":["httpsRequest","httpRequest"],"sources":["../src/analyst/prime-bridge-transport.ts"],"sourcesContent":["import { request as httpRequest } from 'node:http'\nimport { request as httpsRequest } from 'node:https'\n\n/**\n * The bridge seam for the prime analyst protocol: one POST to an\n * OpenAI-compatible `/v1/chat/completions` endpoint, returning the raw status\n * and body text.\n *\n * Deliberately NOT `callLlm` from `../llm-client`, which serves a different\n * contract:\n *  - it retries transient failures, and a prime turn holds a single model seat\n *    for minutes — a silent second attempt doubles the seat time and the spend;\n *  - it normalizes usage, while the protocol's receipt depends on the bridge's\n *    non-standard `model_requests` and `estimated` fields;\n *  - it composes sampling and response-format options the bridge's CLI backends\n *    reject;\n *  - it collapses HTTP status, unparseable body, and empty content into two\n *    error classes, while the protocol classifies them as three distinct\n *    terminal reasons.\n */\nexport interface PrimeBridgeTransportRequest {\n  url: string\n  body: {\n    model: string\n    messages: Array<{ role: 'user'; content: string }>\n  }\n  /**\n   * The call's only deadline. The protocol aborts it on the per-call timeout\n   * and on the caller's cancellation, so a transport that imposes a second\n   * deadline of its own competes with this one.\n   */\n  signal: AbortSignal\n}\n\nexport interface PrimeBridgeTransportResult {\n  status: number\n  text: string\n}\n\n/** One POST to the bridge. Injectable so tests run against a fake bridge. */\nexport type PrimeBridgeTransport = (\n  request: PrimeBridgeTransportRequest,\n) => Promise<PrimeBridgeTransportResult>\n\n/**\n * Default transport on node:http/node:https rather than fetch: undici's fixed\n * response-header timeout kills prime calls that legitimately run past five\n * minutes, so the request's AbortSignal is the only deadline.\n */\nexport function nodeHttpPrimeBridgeTransport(): PrimeBridgeTransport {\n  return ({ url, body, signal }) => {\n    const target = new URL(url)\n    if (target.protocol !== 'http:' && target.protocol !== 'https:') {\n      throw new TypeError(`bridge URL must be http: or https:, got ${target.protocol}`)\n    }\n    const send = target.protocol === 'https:' ? httpsRequest : httpRequest\n    const encoded = JSON.stringify(body)\n    return new Promise((resolvePromise, rejectPromise) => {\n      const req = send(\n        {\n          hostname: target.hostname,\n          port: target.port,\n          // The query string is part of the caller's URL; dropping it would\n          // send the request somewhere other than where the caller pointed.\n          path: `${target.pathname}${target.search}`,\n          method: 'POST',\n          headers: {\n            'content-type': 'application/json',\n            'content-length': Buffer.byteLength(encoded),\n          },\n          signal,\n        },\n        (res) => {\n          const chunks: Buffer[] = []\n          res.on('data', (chunk: Buffer) => chunks.push(chunk))\n          res.on('end', () =>\n            resolvePromise({\n              status: res.statusCode ?? 0,\n              text: Buffer.concat(chunks).toString('utf8'),\n            }),\n          )\n          res.on('error', rejectPromise)\n        },\n      )\n      req.on('error', rejectPromise)\n      req.end(encoded)\n    })\n  }\n}\n"],"mappings":";;;;;;;;AAiDA,SAAgB,+BAAqD;CACnE,QAAQ,EAAE,KAAK,MAAM,aAAa;EAChC,MAAM,SAAS,IAAI,IAAI,GAAG;EAC1B,IAAI,OAAO,aAAa,WAAW,OAAO,aAAa,UACrD,MAAM,IAAI,UAAU,2CAA2C,OAAO,UAAU;EAElF,MAAM,OAAO,OAAO,aAAa,WAAWA,YAAeC;EAC3D,MAAM,UAAU,KAAK,UAAU,IAAI;EACnC,OAAO,IAAI,SAAS,gBAAgB,kBAAkB;GACpD,MAAM,MAAM,KACV;IACE,UAAU,OAAO;IACjB,MAAM,OAAO;IAGb,MAAM,GAAG,OAAO,WAAW,OAAO;IAClC,QAAQ;IACR,SAAS;KACP,gBAAgB;KAChB,kBAAkB,OAAO,WAAW,OAAO;IAC7C;IACA;GACF,IACC,QAAQ;IACP,MAAM,SAAmB,CAAC;IAC1B,IAAI,GAAG,SAAS,UAAkB,OAAO,KAAK,KAAK,CAAC;IACpD,IAAI,GAAG,aACL,eAAe;KACb,QAAQ,IAAI,cAAc;KAC1B,MAAM,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,MAAM;IAC7C,CAAC,CACH;IACA,IAAI,GAAG,SAAS,aAAa;GAC/B,CACF;GACA,IAAI,GAAG,SAAS,aAAa;GAC7B,IAAI,IAAI,OAAO;EACjB,CAAC;CACH;AACF"}
+{"version":3,"file":"prime-bridge-transport-Csd5SQg7.js","names":["httpsRequest","httpRequest"],"sources":["../src/analyst/prime-bridge-transport.ts"],"sourcesContent":["import { request as httpRequest } from 'node:http'\nimport { request as httpsRequest } from 'node:https'\n\n/**\n * The bridge seam for the prime analyst protocol: one POST to an\n * OpenAI-compatible `/v1/chat/completions` endpoint, returning the raw status\n * and body text.\n *\n * Deliberately NOT `callLlm` from `../llm-client`, which serves a different\n * contract:\n *  - it retries transient failures, and a prime turn holds a single model seat\n *    for minutes — a silent second attempt doubles the seat time and the spend;\n *  - it normalizes usage, while the protocol's receipt depends on the bridge's\n *    non-standard `model_requests` and `estimated` fields;\n *  - it composes sampling and response-format options the bridge's CLI backends\n *    reject;\n *  - it collapses HTTP status, unparseable body, and empty content into two\n *    error classes, while the protocol classifies them as three distinct\n *    terminal reasons.\n */\nexport interface PrimeBridgeTransportRequest {\n  url: string\n  body: {\n    model: string\n    messages: Array<{ role: 'user'; content: string }>\n  }\n  /**\n   * The call's only deadline. The protocol aborts it on the per-call timeout\n   * and on the caller's cancellation, so a transport that imposes a second\n   * deadline of its own competes with this one.\n   */\n  signal: AbortSignal\n}\n\nexport interface PrimeBridgeTransportResult {\n  status: number\n  text: string\n}\n\n/** One POST to the bridge. Injectable so tests run against a fake bridge. */\nexport type PrimeBridgeTransport = (\n  request: PrimeBridgeTransportRequest,\n) => Promise<PrimeBridgeTransportResult>\n\n/**\n * Default transport on node:http/node:https rather than fetch: undici's fixed\n * response-header timeout kills prime calls that legitimately run past five\n * minutes, so the request's AbortSignal is the only deadline.\n */\nexport function nodeHttpPrimeBridgeTransport(): PrimeBridgeTransport {\n  return ({ url, body, signal }) => {\n    const target = new URL(url)\n    if (target.protocol !== 'http:' && target.protocol !== 'https:') {\n      throw new TypeError(`bridge URL must be http: or https:, got ${target.protocol}`)\n    }\n    const send = target.protocol === 'https:' ? httpsRequest : httpRequest\n    const encoded = JSON.stringify(body)\n    return new Promise((resolvePromise, rejectPromise) => {\n      const req = send(\n        {\n          hostname: target.hostname,\n          port: target.port,\n          // The query string is part of the caller's URL; dropping it would\n          // send the request somewhere other than where the caller pointed.\n          path: `${target.pathname}${target.search}`,\n          method: 'POST',\n          headers: {\n            'content-type': 'application/json',\n            'content-length': Buffer.byteLength(encoded),\n          },\n          signal,\n        },\n        (res) => {\n          const chunks: Buffer[] = []\n          res.on('data', (chunk: Buffer) => chunks.push(chunk))\n          res.on('end', () =>\n            resolvePromise({\n              status: res.statusCode ?? 0,\n              text: Buffer.concat(chunks).toString('utf8'),\n            }),\n          )\n          res.on('error', rejectPromise)\n        },\n      )\n      req.on('error', rejectPromise)\n      req.end(encoded)\n    })\n  }\n}\n"],"mappings":";;;;;;;;AAiDA,SAAgB,+BAAqD;CACnE,QAAQ,EAAE,KAAK,MAAM,aAAa;EAChC,MAAM,SAAS,IAAI,IAAI,GAAG;EAC1B,IAAI,OAAO,aAAa,WAAW,OAAO,aAAa,UACrD,MAAM,IAAI,UAAU,2CAA2C,OAAO,UAAU;EAElF,MAAM,OAAO,OAAO,aAAa,WAAWA,YAAeC;EAC3D,MAAM,UAAU,KAAK,UAAU,IAAI;EACnC,OAAO,IAAI,SAAS,gBAAgB,kBAAkB;GACpD,MAAM,MAAM,KACV;IACE,UAAU,OAAO;IACjB,MAAM,OAAO;IAGb,MAAM,GAAG,OAAO,WAAW,OAAO;IAClC,QAAQ;IACR,SAAS;KACP,gBAAgB;KAChB,kBAAkB,OAAO,WAAW,OAAO;IAC7C;IACA;GACF,IACC,QAAQ;IACP,MAAM,SAAmB,CAAC;IAC1B,IAAI,GAAG,SAAS,UAAkB,OAAO,KAAK,KAAK,CAAC;IACpD,IAAI,GAAG,aACL,eAAe;KACb,QAAQ,IAAI,cAAc;KAC1B,MAAM,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,MAAM;IAC7C,CAAC,CACH;IACA,IAAI,GAAG,SAAS,aAAa;GAC/B,CACF;GACA,IAAI,GAAG,SAAS,aAAa;GAC7B,IAAI,IAAI,OAAO;EACjB,CAAC;CACH;AACF"}

package/dist/{prime-protocol-BGxjfhM4.d.ts → prime-protocol-COFkxas6.d.ts}

@@ -1,7 +1,6 @@
-import { m as CustomTokenPricing } from "./cost-ledger-C1W3ICmP.js";
-import { p as AnalystUsageReceipt } from "./types-6Lfdlshp.js";
-import { t as PrimeBridgeTransport } from "./prime-bridge-transport-6feEglLf.js";
-//#region src/analyst/reply-contract.d.ts
+import { m as CustomTokenPricing } from "./cost-ledger-Czro9wmo.js";
+import { p as AnalystUsageReceipt } from "./types-DzCO-S1m.js";
+import { t as PrimeBridgeTransport } from "./prime-bridge-transport-Cfqir_Im.js";
 /**
  * The reply grammar an analyst arm holds a model to, independent of transport.
  *
@@ -80,8 +79,6 @@ interface DecodedReply<TRow> {
   /** Valid rows dropped by `maxRows`. */
   overflow: number;
 }
-//#endregion
-//#region src/analyst/prime-protocol.d.ts
 /**
  * The prime analyst protocol: a one-shot RLM reached through an
  * OpenAI-compatible bridge, given the whole trajectory inline because it has no
@@ -308,6 +305,5 @@ interface PrimeProtocolIdentity {
  * claim rather than a label.
  */
 declare function primeProtocolSha256(identity: PrimeProtocolIdentity): string;
-//#endregion
 export { runPrimeExchange as C, ReplyRowDecoded as D, ReplyEnvelope as E, ReplyRowRejection as O, projectPrimeTrajectory as S, ReplyContract as T, buildPrimePrompt as _, PrimeProjectionOutcome as a, normalizePrimeUsage as b, PrimeProtocolIdentity as c, PrimeRepairPromptSpec as d, PrimeRepairState as f, analystUsageReceiptFromPrimeUsage as g, PrimeTurnRecord as h, PrimeProjectionDelivery as i, PrimeRawUsage as l, PrimeRowDecoded as m, PrimeExchangeOutcome as n, PrimeProjectionSource as o, PrimeReplyContract as p, PrimeFailure as r, PrimePromptSpec as s, PrimeExchangeOptions as t, PrimeRejectedRow as u, buildPrimeRepairPrompt as v, DecodedReply as w, primeProtocolSha256 as x, mergePrimeRawUsage as y };
-//# sourceMappingURL=prime-protocol-BGxjfhM4.d.ts.map
+//# sourceMappingURL=prime-protocol-COFkxas6.d.ts.map

package/dist/prime-protocol-COFkxas6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prime-protocol-COFkxas6.d.ts","names":[],"sources":["../src/analyst/reply-contract.ts","../src/analyst/prime-protocol.ts"],"mappings":";;;;;;;;;;;;;KAaY,gBAAgB;EAAU;EAAU,KAAK;;EAAW;EAAW;;;UAG1D;EACf;;EAEA,QAAQ;;UAGO,cAAc;;EAE7B;;EAEA;;;;;EAKA;;;;;;EAMA,UAAU,cAAc,gBAAgB,gBAAgB;;;;;;EAMxD;;;;;;EAMA,eAAe,iBAAiB;;;;;;EAMhC;;;;;EAKA;;;UAIe;EACf;EACA;;UAGe,aAAa;EAC5B,MAAM;;EAEN,QAAQ;EACR,UAAU;;EAEV;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;KC3CU,gBAAgB,QAAQ,gBAAgB;KAExC,mBAAmB,QAAQ,cAAc;UAIpC;EACf;;EAEA;EACA;;EAEA;EACA;;EAEA;;iBAGc,iBAAiB,MAAM;UAatB;EACf;EACA;EACA;;;iBAIc,uBAAuB,MAAM;;;;;;UAoE5B;;;;;;EAMf;;EAEA;;EAEA;;;;;;;EAOA;;;iBAQc,oBAAoB,eAAe;;;;;;iBAgBnC,mBAAmB,GAAG,eAAe,GAAG,gBAAgB;;;;;;;;;;;;;iBA6BxD,kCACd,OAAO,eACP,SAAS,qBACR;;;;;;;;KAqCS;EAEN;EACA;;EAEA;EAAqB;EAAiB;EAAgB;;EACtD;EAAiB;EAAiB;;UAEvB;EACf;;EAEA;;;UAIe;EACf;EACA,OAAO;;EAEP;;UAGe;EACf;EACA;;KAGU,qBAAqB;EAE3B;;EAEA;EACA,MAAM;EACN,UAAU;;EAEV;;EAEA;EACA,OAAO;EACP,OAAO;EACP,QAAQ;EACR;;EAGA;EACA,SAAS;EACT,OAAO;EACP,OAAO;EACP,QAAQ;;EAER;;UAGW,qBAAqB;EACpC,UAAU,mBAAmB;EAC7B;EACA,WAAW;;EAEX;EACA;;EAEA;;EAEA;EACA,SAAS;;;;;;;iBAQW,iBAAiB,MACrC,SAAS,qBAAqB,QAC7B,QAAQ,qBAAqB;;;;;;UAyLf,sBAAsB;;EAErC,QAAQ,iBAAiB;;EAEzB,UAAU,iBAAiB;;EAE3B;;UAGe;EACf;EACA;EACA;;KAGU,uBAAuB;EAE7B;EACA,gBAAgB;EAChB;EACA,UAAU;;EAEV;EAAW;EAAgB;;;;;;;;;iBASX,uBAAuB,OAC3C,QAAQ,sBAAsB,QAC9B;EAAU;IACT,QAAQ,uBAAuB;UA8BjB;EACf;EACA;EACA;EACA;;EAEA,QAAQ,SAAS;;;;;;;;;;;;iBAaH,oBAAoB,UAAU"}

package/dist/{prime-protocol-BFgGrEMP.js → prime-protocol-CrhpXRz9.js}

@@ -1,6 +1,6 @@
-import { s as ValidationError } from "./errors-BcOs5MKW.js";
+import { s as ValidationError } from "./errors-DeEEV9Vx.js";
 import { createHash } from "node:crypto";
-//#region src/analyst/reply-contract.ts
+// src/analyst/reply-contract.ts
 /**
 * The reply grammar an analyst arm holds a model to, independent of transport.
 *
@@ -67,8 +67,7 @@ function decodeReplyRows(contract, value) {
 		overflow
 	};
 }
-//#endregion
-//#region src/analyst/prime-protocol.ts
+// src/analyst/prime-protocol.ts
 function buildPrimePrompt(spec) {
 	return [
 		`QUESTION: ${spec.question}`,
@@ -477,7 +476,6 @@ function primeProtocolSha256(identity) {
 		limits: identity.limits
 	})).digest("hex");
 }
-//#endregion
 export { normalizePrimeUsage as a, runPrimeExchange as c, mergePrimeRawUsage as i, decodeReplyRows as l, buildPrimePrompt as n, primeProtocolSha256 as o, buildPrimeRepairPrompt as r, projectPrimeTrajectory as s, analystUsageReceiptFromPrimeUsage as t };
 
-//# sourceMappingURL=prime-protocol-BFgGrEMP.js.map
+//# sourceMappingURL=prime-protocol-CrhpXRz9.js.map

package/dist/{prime-protocol-BFgGrEMP.js.map → prime-protocol-CrhpXRz9.js.map}

@@ -1 +1 @@
-{"version":3,"file":"prime-protocol-BFgGrEMP.js","names":[],"sources":["../src/analyst/reply-contract.ts","../src/analyst/prime-protocol.ts"],"sourcesContent":["/**\n * The reply grammar an analyst arm holds a model to, independent of transport.\n *\n * One contract serves every arm shape: the inline bridge protocol\n * (`runPrimeExchange`) reads the base fields, and one-shot JSON arms\n * additionally use the strict-envelope and all-rejected knobs. `PrimeReplyContract`\n * in ./prime-protocol is a type alias of this contract, so a consumer written\n * against the prime protocol names the same grammar object.\n */\n\nimport { ValidationError } from '../errors'\n\n/** Verdict of decoding one raw reply row. */\nexport type ReplyRowDecoded<TRow> = { ok: true; row: TRow } | { ok: false; reason: string }\n\n/** A strictly parsed reply envelope: the row array plus retained extras. */\nexport interface ReplyEnvelope {\n  rows: readonly unknown[]\n  /** Envelope fields beside the rows the arm retains (e.g. a `report` string). */\n  extras: Record<string, unknown>\n}\n\nexport interface ReplyContract<TRow> {\n  /** Name of the reply's row array, e.g. `blocks` or `findings`. */\n  rowsField: string\n  /** Row-grammar lines spliced into the first-turn prompt. */\n  contractLines: readonly string[]\n  /**\n   * The same grammar restated for the repair turn, which never carries the\n   * evidence. Empty when the arm declares zero repair turns.\n   */\n  repairContractLines: readonly string[]\n  /**\n   * Validate and convert one raw row in a single pass. One function rather than\n   * a separate validator and constructor, so the two can never disagree about\n   * what a valid row is.\n   */\n  decodeRow(row: unknown, index: number): ReplyRowDecoded<TRow>\n  /**\n   * Cap on ACCEPTED rows. The cap is applied after decoding, so malformed rows\n   * never consume an accepted slot; the surplus is reported as `overflow`.\n   * Omit when the consumer's own expansion owns the cap and records the drop.\n   */\n  maxRows?: number\n  /**\n   * Strict envelope parse for one-shot JSON arms. Throws on an envelope defect\n   * (missing report, unknown key, over-cap row count). When absent, rows are\n   * read from `rowsField` on the parsed reply object.\n   */\n  parseEnvelope?(value: unknown): ReplyEnvelope\n  /**\n   * What a reply whose EVERY reported row was rejected means. `fail` throws a\n   * validation error carrying each rejection; `accept-empty` (the default)\n   * keeps the honest empty result beside the recorded rejections.\n   */\n  whenAllRowsRejected?: 'fail' | 'accept-empty'\n  /**\n   * Message prefix for the `fail` case, in the contract's own row vocabulary\n   * (e.g. \"every reported failure block was malformed\").\n   */\n  allRejectedMessage?: string\n}\n\n/** One rejected row, indexed as the model reported it. */\nexport interface ReplyRowRejection {\n  index: number\n  reason: string\n}\n\nexport interface DecodedReply<TRow> {\n  rows: TRow[]\n  /** Envelope fields beside the rows (empty when the contract has no envelope). */\n  extras: Record<string, unknown>\n  rejected: ReplyRowRejection[]\n  /** Rows the model reported, before decoding or the count cap. */\n  reportedRows: number\n  /** Valid rows dropped by `maxRows`. */\n  overflow: number\n}\n\n/**\n * The per-row half of a decode: validate each raw row under the contract's\n * grammar and cap ACCEPTED rows. Shape before count — a malformed row never\n * consumes an accepted slot. Shared by every consumer of a `ReplyContract`\n * row array, whatever envelope handling surrounds it.\n */\nexport function decodeContractRows<TRow>(\n  contract: Pick<ReplyContract<TRow>, 'decodeRow' | 'maxRows'>,\n  rawRows: readonly unknown[],\n): { rows: TRow[]; rejected: ReplyRowRejection[]; overflow: number } {\n  const rows: TRow[] = []\n  const rejected: ReplyRowRejection[] = []\n  let overflow = 0\n  rawRows.forEach((row, index) => {\n    const decoded = contract.decodeRow(row, index)\n    if (!decoded.ok) {\n      rejected.push({ index, reason: decoded.reason })\n      return\n    }\n    if (contract.maxRows !== undefined && rows.length >= contract.maxRows) {\n      overflow += 1\n      return\n    }\n    rows.push(decoded.row)\n  })\n  return { rows, rejected, overflow }\n}\n\n/**\n * Decode a parsed reply value under a contract: strict envelope when declared,\n * then per-row decoding, then the all-rejected policy.\n */\nexport function decodeReplyRows<TRow>(\n  contract: ReplyContract<TRow>,\n  value: unknown,\n): DecodedReply<TRow> {\n  let rawRows: readonly unknown[]\n  let extras: Record<string, unknown> = {}\n  if (contract.parseEnvelope) {\n    const envelope = contract.parseEnvelope(value)\n    rawRows = envelope.rows\n    extras = envelope.extras\n  } else {\n    const record =\n      typeof value === 'object' && value !== null && !Array.isArray(value)\n        ? (value as Record<string, unknown>)\n        : undefined\n    const field = record?.[contract.rowsField]\n    if (!Array.isArray(field)) {\n      throw new ValidationError(`reply has no \"${contract.rowsField}\" array`)\n    }\n    rawRows = field\n  }\n  const { rows, rejected, overflow } = decodeContractRows(contract, rawRows)\n  if (rows.length === 0 && rawRows.length > 0 && contract.whenAllRowsRejected === 'fail') {\n    throw new ValidationError(\n      `${contract.allRejectedMessage ?? 'every reported row was malformed'}: ${rejected\n        .map((entry) => entry.reason)\n        .join(' | ')}`,\n    )\n  }\n  return { rows, extras, rejected, reportedRows: rawRows.length, overflow }\n}\n","import { createHash } from 'node:crypto'\nimport type { CustomTokenPricing } from '../cost-ledger'\nimport type { PrimeBridgeTransport, PrimeBridgeTransportResult } from './prime-bridge-transport'\nimport { decodeContractRows, type ReplyContract, type ReplyRowDecoded } from './reply-contract'\nimport type { AnalystUsageReceipt } from './types'\n\n/**\n * The prime analyst protocol: a one-shot RLM reached through an\n * OpenAI-compatible bridge, given the whole trajectory inline because it has no\n * REPL and no trace tools, answering in one fenced JSON block of short strings.\n *\n * This module owns every part of that protocol that does not depend on what the\n * rows MEAN: prompt and contract composition, the bounded repair turn, reply\n * extraction, row decoding order, the render-measure-fall-back-fail-loud\n * projection ladder, usage normalization, and the protocol identity digest.\n *\n * The cut: the core speaks RAW ROWS and never names a finding type. It knows a\n * prime reply carries an `answer` string plus an array of rows under a named\n * field, and that each row is decoded by a caller-supplied function. Consumers\n * — the CodeTraceBench benchmark runner here, a span-grounded trace analyzer\n * elsewhere — map decoded rows into their own finding shape on the way out. So\n * nothing in this file may import a block type, a finding type, or a trace\n * store, and no consumer needs another copy of the protocol.\n */\n\n// ── Reply contract ───────────────────────────────────────────────────\n\n/**\n * The prime reply grammar is the general analyst reply contract: these aliases\n * keep every prime-protocol consumer compiling against the shared type in\n * ./reply-contract. The exchange below reads the base fields (`rowsField`,\n * contract lines, `decodeRow`, `maxRows`); the strict-envelope knobs serve\n * one-shot JSON arms and are inert here.\n */\nexport type PrimeRowDecoded<TRow> = ReplyRowDecoded<TRow>\n\nexport type PrimeReplyContract<TRow> = ReplyContract<TRow>\n\n// ── Prompt composition ───────────────────────────────────────────────\n\nexport interface PrimePromptSpec {\n  question: string\n  /** Task definition spliced under a `TASK DEFINITION:` heading. Omit when the question is the whole task. */\n  taskDefinition?: string\n  contractLines: readonly string[]\n  /** Line introducing the trajectory, e.g. `TRAJECTORY (trace_id X; 12 assistant step spans; ...):`. */\n  trajectoryHeader: string\n  renderedTrajectory: string\n  /** Material appended after the trajectory, e.g. the final-verification spans. */\n  trailer?: string\n}\n\nexport function buildPrimePrompt(spec: PrimePromptSpec): string {\n  return [\n    `QUESTION: ${spec.question}`,\n    '',\n    ...(spec.taskDefinition === undefined ? [] : ['TASK DEFINITION:', spec.taskDefinition, '']),\n    ...spec.contractLines,\n    '',\n    spec.trajectoryHeader,\n    spec.renderedTrajectory,\n    ...(spec.trailer === undefined ? [] : ['', spec.trailer]),\n  ].join('\\n')\n}\n\nexport interface PrimeRepairPromptSpec {\n  defect: string\n  previousReply: string\n  repairContractLines: readonly string[]\n}\n\n/** Carries the malformed reply and the contract — never the trajectory. */\nexport function buildPrimeRepairPrompt(spec: PrimeRepairPromptSpec): string {\n  return [\n    'Your previous reply to a trace-analysis task was structurally malformed and could not be parsed',\n    `(${spec.defect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON — one`,\n    'fenced ```json block, no other text, no tools. The JSON object has exactly two fields:',\n    ...spec.repairContractLines,\n    '',\n    'PREVIOUS REPLY:',\n    spec.previousReply,\n  ].join('\\n')\n}\n\n// ── Reply extraction ─────────────────────────────────────────────────\n\n/**\n * Recover the reply's JSON object.\n *\n * Distinct from `extractJsonPayload` in ../llm-client, which serves a response\n * that DECLARES a JSON root and therefore must not scan onward. A prime reply\n * is prose plus a fenced block, and when the model emits several fences the\n * last one is its answer — so fences are scanned in reverse, and only then is a\n * brace-to-brace slice tried.\n */\nfunction extractPrimeJsonObject(text: string): Record<string, unknown> | null {\n  const direct = parsePrimeJsonObject(text)\n  if (direct) return direct\n  const fenced = [...text.matchAll(/```(?:json)?\\s*\\n?([\\s\\S]*?)```/g)]\n  for (let index = fenced.length - 1; index >= 0; index -= 1) {\n    const candidate = parsePrimeJsonObject(fenced[index]![1]!)\n    if (candidate) return candidate\n  }\n  const start = text.indexOf('{')\n  const end = text.lastIndexOf('}')\n  if (start >= 0 && end > start) {\n    const candidate = parsePrimeJsonObject(text.slice(start, end + 1))\n    if (candidate) return candidate\n  }\n  return null\n}\n\n/** Why the reply cannot be read as a prime answer, or null when it can. */\nfunction primeReplyDefect(\n  parsed: Record<string, unknown> | null,\n  rowsField: string,\n): string | null {\n  if (parsed === null) return 'no parseable JSON object'\n  if (!Array.isArray(parsed[rowsField])) return `JSON has no \"${rowsField}\" array`\n  return null\n}\n\nfunction parsePrimeJsonObject(text: string): Record<string, unknown> | null {\n  try {\n    const value: unknown = JSON.parse(text.trim())\n    return typeof value === 'object' && value !== null && !Array.isArray(value)\n      ? (value as Record<string, unknown>)\n      : null\n  } catch {\n    return null\n  }\n}\n\n// ── Usage ────────────────────────────────────────────────────────────\n\n/**\n * Token accounting exactly as the bridge reported it. Lossless on purpose: a\n * side the bridge did not report stays null rather than becoming a zero, and a\n * side it DID report survives even when its partner is missing.\n */\nexport interface PrimeRawUsage {\n  /**\n   * Model-usage records the bridge observed. NOT a count of bridge round trips:\n   * one prime turn routes several internal model calls, so a single turn\n   * typically reports 3-5.\n   */\n  calls: number | null\n  /** Prompt tokens the bridge reported; null when it reported none. */\n  inputTokens: number | null\n  /** Completion tokens the bridge reported; null when it reported none. */\n  outputTokens: number | null\n  /**\n   * True when the bridge DERIVED the counts (from character lengths) because\n   * the backend reported no usage of its own. Pricing derived counts produces a\n   * guess about a guess, which a reader must be able to tell apart from a\n   * rate-estimated cost over exact tokens.\n   */\n  bridgeEstimated: boolean\n}\n\nfunction emptyPrimeRawUsage(): PrimeRawUsage {\n  return { calls: null, inputTokens: null, outputTokens: null, bridgeEstimated: false }\n}\n\n/** Read the bridge's OpenAI-shaped `usage` object. */\nexport function normalizePrimeUsage(raw: unknown): PrimeRawUsage {\n  if (typeof raw !== 'object' || raw === null) return emptyPrimeRawUsage()\n  const record = raw as Record<string, unknown>\n  return {\n    calls: tokenCountOrNull(record.model_requests),\n    inputTokens: tokenCountOrNull(record.prompt_tokens),\n    outputTokens: tokenCountOrNull(record.completion_tokens),\n    bridgeEstimated: record.estimated === true,\n  }\n}\n\n/**\n * Sum two turns. Each side poisons independently: two turns that both report\n * input and neither report output yield a real input total beside a null\n * output, because discarding a measured count is as wrong as inventing one.\n */\nexport function mergePrimeRawUsage(a: PrimeRawUsage, b: PrimeRawUsage): PrimeRawUsage {\n  return {\n    calls: sumOrNull(a.calls, b.calls),\n    inputTokens: sumOrNull(a.inputTokens, b.inputTokens),\n    outputTokens: sumOrNull(a.outputTokens, b.outputTokens),\n    bridgeEstimated: a.bridgeEstimated || b.bridgeEstimated,\n  }\n}\n\nfunction sumOrNull(a: number | null, b: number | null): number | null {\n  return a !== null && b !== null ? a + b : null\n}\n\nfunction tokenCountOrNull(value: unknown): number | null {\n  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null\n}\n\n/**\n * Bind raw prime usage to agent-eval's typed receipt.\n *\n * `RunTokenUsage.input` and `.output` are non-nullable, so a one-sided count\n * cannot round-trip through `tokens` without writing a zero nobody measured.\n * The complete-accounting field therefore stays null, the reported side is\n * carried verbatim in `partialTokens`, and its price becomes the receipt's\n * `knownCostUsd` lower bound.\n *\n * Only agent-eval calls this; consumers with no pricing table read\n * `PrimeRawUsage` directly.\n */\nexport function analystUsageReceiptFromPrimeUsage(\n  usage: PrimeRawUsage,\n  pricing: CustomTokenPricing,\n): AnalystUsageReceipt {\n  const { calls, inputTokens, outputTokens, bridgeEstimated } = usage\n  const estimatedTokens = bridgeEstimated ? { tokensEstimated: true } : {}\n  if (inputTokens !== null && outputTokens !== null) {\n    return {\n      calls,\n      tokens: { input: inputTokens, output: outputTokens },\n      cost: { kind: 'estimated', usd: priceTokens(inputTokens, outputTokens, pricing) },\n      ...estimatedTokens,\n    }\n  }\n  if (inputTokens === null && outputTokens === null) {\n    return { calls, tokens: null, cost: { kind: 'uncaptured', usd: null }, ...estimatedTokens }\n  }\n  return {\n    calls,\n    tokens: null,\n    partialTokens: { input: inputTokens, output: outputTokens },\n    cost: { kind: 'uncaptured', usd: null },\n    knownCostUsd: priceTokens(inputTokens ?? 0, outputTokens ?? 0, pricing),\n    ...estimatedTokens,\n  }\n}\n\nfunction priceTokens(input: number, output: number, pricing: CustomTokenPricing): number {\n  return (input * pricing.inputUsdPerMillion + output * pricing.outputUsdPerMillion) / 1_000_000\n}\n\n// ── Two-turn exchange ────────────────────────────────────────────────\n\n/**\n * Why an exchange ended without a readable reply. `deadline` and `aborted` are\n * separate members from `transport` on purpose: a model that ran past its\n * deadline, a caller who cancelled, and a bridge that refused the connection\n * demand three different responses, and a record that conflates them cannot be\n * acted on.\n */\nexport type PrimeFailure =\n  | {\n      kind: 'transport' | 'unparseable-json' | 'no-content' | 'deadline' | 'malformed-reply'\n      message: string\n    }\n  | { kind: 'http-status'; message: string; status: number; bodySnippet: string }\n  | { kind: 'aborted'; message: string; cause: unknown }\n\nexport interface PrimeRepairState {\n  attempted: boolean\n  /** Null when no repair turn ran, or when the repair turn never returned a reply. */\n  succeeded: boolean | null\n}\n\n/** One completed bridge turn. A turn that failed produces no record. */\nexport interface PrimeTurnRecord {\n  turn: 'first' | 'repair'\n  usage: PrimeRawUsage\n  /** The reply's `usage` object verbatim; null when the bridge sent none. */\n  rawUsage: unknown\n}\n\nexport interface PrimeRejectedRow {\n  index: number\n  reason: string\n}\n\nexport type PrimeExchangeOutcome<TRow> =\n  | {\n      ok: true\n      /** The reply's `answer` field; null when absent or not a string. */\n      answer: string | null\n      rows: TRow[]\n      rejected: PrimeRejectedRow[]\n      /** Rows the model reported, before decoding or the count cap. */\n      reportedRows: number\n      /** Valid rows dropped by `contract.maxRows`. */\n      overflow: number\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      reply: string\n    }\n  | {\n      ok: false\n      failure: PrimeFailure\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      /** The last reply received, when one arrived — the diagnostic artifact for a malformed case. */\n      reply?: string\n    }\n\nexport interface PrimeExchangeOptions<TRow> {\n  contract: PrimeReplyContract<TRow>\n  prompt: string\n  transport: PrimeBridgeTransport\n  /** Full endpoint, e.g. `http://localhost:4181/v1/chat/completions`. */\n  url: string\n  model: string\n  /** Deadline for ONE turn. Prime analyses routinely exceed five minutes. */\n  timeoutMs: number\n  /** Whether a structurally malformed reply gets one bounded repair turn. */\n  repair: boolean\n  signal?: AbortSignal\n}\n\n/**\n * Run the protocol: one call, one bounded repair turn on a structurally\n * malformed reply, then decode. Zero valid rows from a well-formed reply is an\n * honest null, not a failure.\n */\nexport async function runPrimeExchange<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n): Promise<PrimeExchangeOutcome<TRow>> {\n  const { contract } = options\n  const turns: PrimeTurnRecord[] = []\n  const repair: PrimeRepairState = { attempted: false, succeeded: null }\n\n  const first = await callPrimeTurn(options, options.prompt)\n  if (!first.ok) {\n    return { ok: false, failure: first.failure, usage: mergeTurns(turns), turns, repair }\n  }\n  turns.push({ turn: 'first', usage: first.usage, rawUsage: first.rawUsage })\n\n  let reply = first.content\n  let parsed = extractPrimeJsonObject(reply)\n  let defect = primeReplyDefect(parsed, contract.rowsField)\n\n  if (defect !== null && options.repair) {\n    repair.attempted = true\n    const second = await callPrimeTurn(\n      options,\n      buildPrimeRepairPrompt({\n        defect,\n        previousReply: reply,\n        repairContractLines: contract.repairContractLines,\n      }),\n    )\n    if (!second.ok) {\n      return { ok: false, failure: second.failure, usage: mergeTurns(turns), turns, repair, reply }\n    }\n    turns.push({ turn: 'repair', usage: second.usage, rawUsage: second.rawUsage })\n    reply = second.content\n    parsed = extractPrimeJsonObject(reply)\n    defect = primeReplyDefect(parsed, contract.rowsField)\n    repair.succeeded = defect === null\n  }\n\n  const usage = mergeTurns(turns)\n  if (defect !== null) {\n    return {\n      ok: false,\n      failure: {\n        kind: 'malformed-reply',\n        message: `${defect} in prime reply${repair.attempted ? ' even after the bounded repair turn' : ''}`,\n      },\n      usage,\n      turns,\n      repair,\n      reply,\n    }\n  }\n\n  const rawRows = parsed![contract.rowsField] as unknown[]\n  const { rows, rejected, overflow } = decodeContractRows(contract, rawRows)\n  const answer = parsed!.answer\n  return {\n    ok: true,\n    answer: typeof answer === 'string' ? answer : null,\n    rows,\n    rejected,\n    reportedRows: rawRows.length,\n    overflow,\n    usage,\n    turns,\n    repair,\n    reply,\n  }\n}\n\ntype PrimeTurnOutcome =\n  | { ok: true; content: string; usage: PrimeRawUsage; rawUsage: unknown }\n  | { ok: false; failure: PrimeFailure }\n\nasync function callPrimeTurn<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n  content: string,\n): Promise<PrimeTurnOutcome> {\n  const { transport, url, model, timeoutMs, signal } = options\n  const controller = new AbortController()\n  const forwardAbort = () => controller.abort(signal?.reason)\n  if (signal?.aborted) controller.abort(signal.reason)\n  else signal?.addEventListener('abort', forwardAbort, { once: true })\n  const deadline = setTimeout(() => controller.abort(), timeoutMs)\n  let result: PrimeBridgeTransportResult\n  try {\n    result = await transport({\n      url,\n      body: { model, messages: [{ role: 'user', content }] },\n      signal: controller.signal,\n    })\n  } catch (error) {\n    if (signal?.aborted) {\n      return {\n        ok: false,\n        failure: {\n          kind: 'aborted',\n          message: 'prime exchange cancelled by the caller',\n          cause: error,\n        },\n      }\n    }\n    if (controller.signal.aborted) {\n      return {\n        ok: false,\n        failure: { kind: 'deadline', message: `bridge call exceeded ${timeoutMs}ms` },\n      }\n    }\n    return {\n      ok: false,\n      failure: {\n        kind: 'transport',\n        message: `bridge transport failure: ${error instanceof Error ? error.message : String(error)}`,\n      },\n    }\n  } finally {\n    clearTimeout(deadline)\n    signal?.removeEventListener('abort', forwardAbort)\n  }\n\n  if (result.status !== 200) {\n    const bodySnippet = result.text.slice(0, 500)\n    return {\n      ok: false,\n      failure: {\n        kind: 'http-status',\n        message: `bridge HTTP ${result.status}: ${bodySnippet}`,\n        status: result.status,\n        bodySnippet,\n      },\n    }\n  }\n  let response: unknown\n  try {\n    response = JSON.parse(result.text)\n  } catch {\n    return {\n      ok: false,\n      failure: {\n        kind: 'unparseable-json',\n        message: `bridge returned unparseable JSON (${result.text.length} bytes)`,\n      },\n    }\n  }\n  const replyContent = primeReplyContent(response)\n  if (replyContent === null) {\n    return {\n      ok: false,\n      failure: { kind: 'no-content', message: 'bridge reply carries no message content' },\n    }\n  }\n  const rawUsage = primeReplyUsage(response)\n  return { ok: true, content: replyContent, usage: normalizePrimeUsage(rawUsage), rawUsage }\n}\n\n/**\n * Fold from the FIRST turn, never from an empty receipt: an all-null identity\n * would poison every side it merged with and erase counts the bridge reported.\n */\nfunction mergeTurns(turns: readonly PrimeTurnRecord[]): PrimeRawUsage {\n  if (turns.length === 0) return emptyPrimeRawUsage()\n  return turns\n    .slice(1)\n    .reduce<PrimeRawUsage>((total, turn) => mergePrimeRawUsage(total, turn.usage), turns[0]!.usage)\n}\n\nfunction primeReplyContent(response: unknown): string | null {\n  if (typeof response !== 'object' || response === null) return null\n  const choices = (response as { choices?: unknown }).choices\n  if (!Array.isArray(choices) || choices.length === 0) return null\n  const message = (choices[0] as { message?: unknown })?.message\n  if (typeof message !== 'object' || message === null) return null\n  const content = (message as { content?: unknown }).content\n  return typeof content === 'string' && content.length > 0 ? content : null\n}\n\nfunction primeReplyUsage(response: unknown): unknown {\n  if (typeof response !== 'object' || response === null) return null\n  return (response as { usage?: unknown }).usage ?? null\n}\n\n// ── Trajectory projection ────────────────────────────────────────────\n\n/**\n * Where the inlined trajectory comes from. The protocol needs only two moves —\n * fetch it all, or fetch a reduced version — so no store, artifact path, or\n * span type enters the shared signature.\n */\nexport interface PrimeProjectionSource<TItem> {\n  /** The full projection, or null when the source declares itself oversized. */\n  full(): Promise<readonly TItem[] | null>\n  /** A reduced projection of the same material. */\n  capped(): Promise<readonly TItem[]>\n  /** How `capped` reduces, named for the failure message, e.g. `per-attribute cap 1200`. */\n  cappedDescription: string\n}\n\nexport interface PrimeProjectionDelivery {\n  mode: 'inline-json'\n  fetch: 'full' | 'capped'\n  renderedChars: number\n}\n\nexport type PrimeProjectionOutcome<TItem> =\n  | {\n      ok: true\n      items: readonly TItem[]\n      rendered: string\n      delivery: PrimeProjectionDelivery\n    }\n  | { ok: false; reason: string; renderedChars: number }\n\n/**\n * Render, measure, fall back to the capped projection, re-measure, fail loud.\n *\n * Inline is the only delivery prime has, so an oversized trajectory is a\n * refusal rather than a silent truncation: dropping spans would understate the\n * trajectory and the analyst would answer a question about a different run.\n */\nexport async function projectPrimeTrajectory<TItem>(\n  source: PrimeProjectionSource<TItem>,\n  limits: { maxInlineChars: number },\n): Promise<PrimeProjectionOutcome<TItem>> {\n  let fetch: PrimeProjectionDelivery['fetch'] = 'full'\n  let items = await source.full()\n  if (items === null) {\n    fetch = 'capped'\n    items = await source.capped()\n  }\n  let rendered = JSON.stringify(items)\n  if (rendered.length > limits.maxInlineChars && fetch === 'full') {\n    fetch = 'capped'\n    items = await source.capped()\n    rendered = JSON.stringify(items)\n  }\n  if (rendered.length > limits.maxInlineChars) {\n    return {\n      ok: false,\n      reason: `trajectory renders to ${rendered.length} chars even at ${source.cappedDescription}; inline delivery impossible`,\n      renderedChars: rendered.length,\n    }\n  }\n  return {\n    ok: true,\n    items,\n    rendered,\n    delivery: { mode: 'inline-json', fetch, renderedChars: rendered.length },\n  }\n}\n\n// ── Protocol identity ────────────────────────────────────────────────\n\nexport interface PrimeProtocolIdentity {\n  question: string\n  taskDefinition?: string\n  contractLines: readonly string[]\n  repairContractLines: readonly string[]\n  /** Numeric limits the contract states, e.g. row and width caps. */\n  limits: Readonly<Record<string, number>>\n}\n\n/**\n * Digest of everything a consumer can send to the bridge under the prime\n * protocol, recorded per observation so a prime result names the exact contract\n * that produced it.\n *\n * Computed over the ACTUALLY composed contract, so two consumers that both\n * stamp `analyst_id: 'prime'` while asking materially different questions get\n * different digests by construction. That is what makes 'prime' a reproducible\n * claim rather than a label.\n */\nexport function primeProtocolSha256(identity: PrimeProtocolIdentity): string {\n  return createHash('sha256')\n    .update(\n      JSON.stringify({\n        kind: 'prime-analyst-protocol',\n        question: identity.question,\n        taskPrompt: identity.taskDefinition ?? null,\n        outputContract: identity.contractLines,\n        repairContract: buildPrimeRepairPrompt({\n          defect: '<defect>',\n          previousReply: '<previous-reply>',\n          repairContractLines: identity.repairContractLines,\n        }),\n        limits: identity.limits,\n      }),\n    )\n    .digest('hex')\n}\n"],"mappings":"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"}
+{"version":3,"file":"prime-protocol-CrhpXRz9.js","names":[],"sources":["../src/analyst/reply-contract.ts","../src/analyst/prime-protocol.ts"],"sourcesContent":["/**\n * The reply grammar an analyst arm holds a model to, independent of transport.\n *\n * One contract serves every arm shape: the inline bridge protocol\n * (`runPrimeExchange`) reads the base fields, and one-shot JSON arms\n * additionally use the strict-envelope and all-rejected knobs. `PrimeReplyContract`\n * in ./prime-protocol is a type alias of this contract, so a consumer written\n * against the prime protocol names the same grammar object.\n */\n\nimport { ValidationError } from '../errors'\n\n/** Verdict of decoding one raw reply row. */\nexport type ReplyRowDecoded<TRow> = { ok: true; row: TRow } | { ok: false; reason: string }\n\n/** A strictly parsed reply envelope: the row array plus retained extras. */\nexport interface ReplyEnvelope {\n  rows: readonly unknown[]\n  /** Envelope fields beside the rows the arm retains (e.g. a `report` string). */\n  extras: Record<string, unknown>\n}\n\nexport interface ReplyContract<TRow> {\n  /** Name of the reply's row array, e.g. `blocks` or `findings`. */\n  rowsField: string\n  /** Row-grammar lines spliced into the first-turn prompt. */\n  contractLines: readonly string[]\n  /**\n   * The same grammar restated for the repair turn, which never carries the\n   * evidence. Empty when the arm declares zero repair turns.\n   */\n  repairContractLines: readonly string[]\n  /**\n   * Validate and convert one raw row in a single pass. One function rather than\n   * a separate validator and constructor, so the two can never disagree about\n   * what a valid row is.\n   */\n  decodeRow(row: unknown, index: number): ReplyRowDecoded<TRow>\n  /**\n   * Cap on ACCEPTED rows. The cap is applied after decoding, so malformed rows\n   * never consume an accepted slot; the surplus is reported as `overflow`.\n   * Omit when the consumer's own expansion owns the cap and records the drop.\n   */\n  maxRows?: number\n  /**\n   * Strict envelope parse for one-shot JSON arms. Throws on an envelope defect\n   * (missing report, unknown key, over-cap row count). When absent, rows are\n   * read from `rowsField` on the parsed reply object.\n   */\n  parseEnvelope?(value: unknown): ReplyEnvelope\n  /**\n   * What a reply whose EVERY reported row was rejected means. `fail` throws a\n   * validation error carrying each rejection; `accept-empty` (the default)\n   * keeps the honest empty result beside the recorded rejections.\n   */\n  whenAllRowsRejected?: 'fail' | 'accept-empty'\n  /**\n   * Message prefix for the `fail` case, in the contract's own row vocabulary\n   * (e.g. \"every reported failure block was malformed\").\n   */\n  allRejectedMessage?: string\n}\n\n/** One rejected row, indexed as the model reported it. */\nexport interface ReplyRowRejection {\n  index: number\n  reason: string\n}\n\nexport interface DecodedReply<TRow> {\n  rows: TRow[]\n  /** Envelope fields beside the rows (empty when the contract has no envelope). */\n  extras: Record<string, unknown>\n  rejected: ReplyRowRejection[]\n  /** Rows the model reported, before decoding or the count cap. */\n  reportedRows: number\n  /** Valid rows dropped by `maxRows`. */\n  overflow: number\n}\n\n/**\n * The per-row half of a decode: validate each raw row under the contract's\n * grammar and cap ACCEPTED rows. Shape before count — a malformed row never\n * consumes an accepted slot. Shared by every consumer of a `ReplyContract`\n * row array, whatever envelope handling surrounds it.\n */\nexport function decodeContractRows<TRow>(\n  contract: Pick<ReplyContract<TRow>, 'decodeRow' | 'maxRows'>,\n  rawRows: readonly unknown[],\n): { rows: TRow[]; rejected: ReplyRowRejection[]; overflow: number } {\n  const rows: TRow[] = []\n  const rejected: ReplyRowRejection[] = []\n  let overflow = 0\n  rawRows.forEach((row, index) => {\n    const decoded = contract.decodeRow(row, index)\n    if (!decoded.ok) {\n      rejected.push({ index, reason: decoded.reason })\n      return\n    }\n    if (contract.maxRows !== undefined && rows.length >= contract.maxRows) {\n      overflow += 1\n      return\n    }\n    rows.push(decoded.row)\n  })\n  return { rows, rejected, overflow }\n}\n\n/**\n * Decode a parsed reply value under a contract: strict envelope when declared,\n * then per-row decoding, then the all-rejected policy.\n */\nexport function decodeReplyRows<TRow>(\n  contract: ReplyContract<TRow>,\n  value: unknown,\n): DecodedReply<TRow> {\n  let rawRows: readonly unknown[]\n  let extras: Record<string, unknown> = {}\n  if (contract.parseEnvelope) {\n    const envelope = contract.parseEnvelope(value)\n    rawRows = envelope.rows\n    extras = envelope.extras\n  } else {\n    const record =\n      typeof value === 'object' && value !== null && !Array.isArray(value)\n        ? (value as Record<string, unknown>)\n        : undefined\n    const field = record?.[contract.rowsField]\n    if (!Array.isArray(field)) {\n      throw new ValidationError(`reply has no \"${contract.rowsField}\" array`)\n    }\n    rawRows = field\n  }\n  const { rows, rejected, overflow } = decodeContractRows(contract, rawRows)\n  if (rows.length === 0 && rawRows.length > 0 && contract.whenAllRowsRejected === 'fail') {\n    throw new ValidationError(\n      `${contract.allRejectedMessage ?? 'every reported row was malformed'}: ${rejected\n        .map((entry) => entry.reason)\n        .join(' | ')}`,\n    )\n  }\n  return { rows, extras, rejected, reportedRows: rawRows.length, overflow }\n}\n","import { createHash } from 'node:crypto'\nimport type { CustomTokenPricing } from '../cost-ledger'\nimport type { PrimeBridgeTransport, PrimeBridgeTransportResult } from './prime-bridge-transport'\nimport { decodeContractRows, type ReplyContract, type ReplyRowDecoded } from './reply-contract'\nimport type { AnalystUsageReceipt } from './types'\n\n/**\n * The prime analyst protocol: a one-shot RLM reached through an\n * OpenAI-compatible bridge, given the whole trajectory inline because it has no\n * REPL and no trace tools, answering in one fenced JSON block of short strings.\n *\n * This module owns every part of that protocol that does not depend on what the\n * rows MEAN: prompt and contract composition, the bounded repair turn, reply\n * extraction, row decoding order, the render-measure-fall-back-fail-loud\n * projection ladder, usage normalization, and the protocol identity digest.\n *\n * The cut: the core speaks RAW ROWS and never names a finding type. It knows a\n * prime reply carries an `answer` string plus an array of rows under a named\n * field, and that each row is decoded by a caller-supplied function. Consumers\n * — the CodeTraceBench benchmark runner here, a span-grounded trace analyzer\n * elsewhere — map decoded rows into their own finding shape on the way out. So\n * nothing in this file may import a block type, a finding type, or a trace\n * store, and no consumer needs another copy of the protocol.\n */\n\n// ── Reply contract ───────────────────────────────────────────────────\n\n/**\n * The prime reply grammar is the general analyst reply contract: these aliases\n * keep every prime-protocol consumer compiling against the shared type in\n * ./reply-contract. The exchange below reads the base fields (`rowsField`,\n * contract lines, `decodeRow`, `maxRows`); the strict-envelope knobs serve\n * one-shot JSON arms and are inert here.\n */\nexport type PrimeRowDecoded<TRow> = ReplyRowDecoded<TRow>\n\nexport type PrimeReplyContract<TRow> = ReplyContract<TRow>\n\n// ── Prompt composition ───────────────────────────────────────────────\n\nexport interface PrimePromptSpec {\n  question: string\n  /** Task definition spliced under a `TASK DEFINITION:` heading. Omit when the question is the whole task. */\n  taskDefinition?: string\n  contractLines: readonly string[]\n  /** Line introducing the trajectory, e.g. `TRAJECTORY (trace_id X; 12 assistant step spans; ...):`. */\n  trajectoryHeader: string\n  renderedTrajectory: string\n  /** Material appended after the trajectory, e.g. the final-verification spans. */\n  trailer?: string\n}\n\nexport function buildPrimePrompt(spec: PrimePromptSpec): string {\n  return [\n    `QUESTION: ${spec.question}`,\n    '',\n    ...(spec.taskDefinition === undefined ? [] : ['TASK DEFINITION:', spec.taskDefinition, '']),\n    ...spec.contractLines,\n    '',\n    spec.trajectoryHeader,\n    spec.renderedTrajectory,\n    ...(spec.trailer === undefined ? [] : ['', spec.trailer]),\n  ].join('\\n')\n}\n\nexport interface PrimeRepairPromptSpec {\n  defect: string\n  previousReply: string\n  repairContractLines: readonly string[]\n}\n\n/** Carries the malformed reply and the contract — never the trajectory. */\nexport function buildPrimeRepairPrompt(spec: PrimeRepairPromptSpec): string {\n  return [\n    'Your previous reply to a trace-analysis task was structurally malformed and could not be parsed',\n    `(${spec.defect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON — one`,\n    'fenced ```json block, no other text, no tools. The JSON object has exactly two fields:',\n    ...spec.repairContractLines,\n    '',\n    'PREVIOUS REPLY:',\n    spec.previousReply,\n  ].join('\\n')\n}\n\n// ── Reply extraction ─────────────────────────────────────────────────\n\n/**\n * Recover the reply's JSON object.\n *\n * Distinct from `extractJsonPayload` in ../llm-client, which serves a response\n * that DECLARES a JSON root and therefore must not scan onward. A prime reply\n * is prose plus a fenced block, and when the model emits several fences the\n * last one is its answer — so fences are scanned in reverse, and only then is a\n * brace-to-brace slice tried.\n */\nfunction extractPrimeJsonObject(text: string): Record<string, unknown> | null {\n  const direct = parsePrimeJsonObject(text)\n  if (direct) return direct\n  const fenced = [...text.matchAll(/```(?:json)?\\s*\\n?([\\s\\S]*?)```/g)]\n  for (let index = fenced.length - 1; index >= 0; index -= 1) {\n    const candidate = parsePrimeJsonObject(fenced[index]![1]!)\n    if (candidate) return candidate\n  }\n  const start = text.indexOf('{')\n  const end = text.lastIndexOf('}')\n  if (start >= 0 && end > start) {\n    const candidate = parsePrimeJsonObject(text.slice(start, end + 1))\n    if (candidate) return candidate\n  }\n  return null\n}\n\n/** Why the reply cannot be read as a prime answer, or null when it can. */\nfunction primeReplyDefect(\n  parsed: Record<string, unknown> | null,\n  rowsField: string,\n): string | null {\n  if (parsed === null) return 'no parseable JSON object'\n  if (!Array.isArray(parsed[rowsField])) return `JSON has no \"${rowsField}\" array`\n  return null\n}\n\nfunction parsePrimeJsonObject(text: string): Record<string, unknown> | null {\n  try {\n    const value: unknown = JSON.parse(text.trim())\n    return typeof value === 'object' && value !== null && !Array.isArray(value)\n      ? (value as Record<string, unknown>)\n      : null\n  } catch {\n    return null\n  }\n}\n\n// ── Usage ────────────────────────────────────────────────────────────\n\n/**\n * Token accounting exactly as the bridge reported it. Lossless on purpose: a\n * side the bridge did not report stays null rather than becoming a zero, and a\n * side it DID report survives even when its partner is missing.\n */\nexport interface PrimeRawUsage {\n  /**\n   * Model-usage records the bridge observed. NOT a count of bridge round trips:\n   * one prime turn routes several internal model calls, so a single turn\n   * typically reports 3-5.\n   */\n  calls: number | null\n  /** Prompt tokens the bridge reported; null when it reported none. */\n  inputTokens: number | null\n  /** Completion tokens the bridge reported; null when it reported none. */\n  outputTokens: number | null\n  /**\n   * True when the bridge DERIVED the counts (from character lengths) because\n   * the backend reported no usage of its own. Pricing derived counts produces a\n   * guess about a guess, which a reader must be able to tell apart from a\n   * rate-estimated cost over exact tokens.\n   */\n  bridgeEstimated: boolean\n}\n\nfunction emptyPrimeRawUsage(): PrimeRawUsage {\n  return { calls: null, inputTokens: null, outputTokens: null, bridgeEstimated: false }\n}\n\n/** Read the bridge's OpenAI-shaped `usage` object. */\nexport function normalizePrimeUsage(raw: unknown): PrimeRawUsage {\n  if (typeof raw !== 'object' || raw === null) return emptyPrimeRawUsage()\n  const record = raw as Record<string, unknown>\n  return {\n    calls: tokenCountOrNull(record.model_requests),\n    inputTokens: tokenCountOrNull(record.prompt_tokens),\n    outputTokens: tokenCountOrNull(record.completion_tokens),\n    bridgeEstimated: record.estimated === true,\n  }\n}\n\n/**\n * Sum two turns. Each side poisons independently: two turns that both report\n * input and neither report output yield a real input total beside a null\n * output, because discarding a measured count is as wrong as inventing one.\n */\nexport function mergePrimeRawUsage(a: PrimeRawUsage, b: PrimeRawUsage): PrimeRawUsage {\n  return {\n    calls: sumOrNull(a.calls, b.calls),\n    inputTokens: sumOrNull(a.inputTokens, b.inputTokens),\n    outputTokens: sumOrNull(a.outputTokens, b.outputTokens),\n    bridgeEstimated: a.bridgeEstimated || b.bridgeEstimated,\n  }\n}\n\nfunction sumOrNull(a: number | null, b: number | null): number | null {\n  return a !== null && b !== null ? a + b : null\n}\n\nfunction tokenCountOrNull(value: unknown): number | null {\n  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null\n}\n\n/**\n * Bind raw prime usage to agent-eval's typed receipt.\n *\n * `RunTokenUsage.input` and `.output` are non-nullable, so a one-sided count\n * cannot round-trip through `tokens` without writing a zero nobody measured.\n * The complete-accounting field therefore stays null, the reported side is\n * carried verbatim in `partialTokens`, and its price becomes the receipt's\n * `knownCostUsd` lower bound.\n *\n * Only agent-eval calls this; consumers with no pricing table read\n * `PrimeRawUsage` directly.\n */\nexport function analystUsageReceiptFromPrimeUsage(\n  usage: PrimeRawUsage,\n  pricing: CustomTokenPricing,\n): AnalystUsageReceipt {\n  const { calls, inputTokens, outputTokens, bridgeEstimated } = usage\n  const estimatedTokens = bridgeEstimated ? { tokensEstimated: true } : {}\n  if (inputTokens !== null && outputTokens !== null) {\n    return {\n      calls,\n      tokens: { input: inputTokens, output: outputTokens },\n      cost: { kind: 'estimated', usd: priceTokens(inputTokens, outputTokens, pricing) },\n      ...estimatedTokens,\n    }\n  }\n  if (inputTokens === null && outputTokens === null) {\n    return { calls, tokens: null, cost: { kind: 'uncaptured', usd: null }, ...estimatedTokens }\n  }\n  return {\n    calls,\n    tokens: null,\n    partialTokens: { input: inputTokens, output: outputTokens },\n    cost: { kind: 'uncaptured', usd: null },\n    knownCostUsd: priceTokens(inputTokens ?? 0, outputTokens ?? 0, pricing),\n    ...estimatedTokens,\n  }\n}\n\nfunction priceTokens(input: number, output: number, pricing: CustomTokenPricing): number {\n  return (input * pricing.inputUsdPerMillion + output * pricing.outputUsdPerMillion) / 1_000_000\n}\n\n// ── Two-turn exchange ────────────────────────────────────────────────\n\n/**\n * Why an exchange ended without a readable reply. `deadline` and `aborted` are\n * separate members from `transport` on purpose: a model that ran past its\n * deadline, a caller who cancelled, and a bridge that refused the connection\n * demand three different responses, and a record that conflates them cannot be\n * acted on.\n */\nexport type PrimeFailure =\n  | {\n      kind: 'transport' | 'unparseable-json' | 'no-content' | 'deadline' | 'malformed-reply'\n      message: string\n    }\n  | { kind: 'http-status'; message: string; status: number; bodySnippet: string }\n  | { kind: 'aborted'; message: string; cause: unknown }\n\nexport interface PrimeRepairState {\n  attempted: boolean\n  /** Null when no repair turn ran, or when the repair turn never returned a reply. */\n  succeeded: boolean | null\n}\n\n/** One completed bridge turn. A turn that failed produces no record. */\nexport interface PrimeTurnRecord {\n  turn: 'first' | 'repair'\n  usage: PrimeRawUsage\n  /** The reply's `usage` object verbatim; null when the bridge sent none. */\n  rawUsage: unknown\n}\n\nexport interface PrimeRejectedRow {\n  index: number\n  reason: string\n}\n\nexport type PrimeExchangeOutcome<TRow> =\n  | {\n      ok: true\n      /** The reply's `answer` field; null when absent or not a string. */\n      answer: string | null\n      rows: TRow[]\n      rejected: PrimeRejectedRow[]\n      /** Rows the model reported, before decoding or the count cap. */\n      reportedRows: number\n      /** Valid rows dropped by `contract.maxRows`. */\n      overflow: number\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      reply: string\n    }\n  | {\n      ok: false\n      failure: PrimeFailure\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      /** The last reply received, when one arrived — the diagnostic artifact for a malformed case. */\n      reply?: string\n    }\n\nexport interface PrimeExchangeOptions<TRow> {\n  contract: PrimeReplyContract<TRow>\n  prompt: string\n  transport: PrimeBridgeTransport\n  /** Full endpoint, e.g. `http://localhost:4181/v1/chat/completions`. */\n  url: string\n  model: string\n  /** Deadline for ONE turn. Prime analyses routinely exceed five minutes. */\n  timeoutMs: number\n  /** Whether a structurally malformed reply gets one bounded repair turn. */\n  repair: boolean\n  signal?: AbortSignal\n}\n\n/**\n * Run the protocol: one call, one bounded repair turn on a structurally\n * malformed reply, then decode. Zero valid rows from a well-formed reply is an\n * honest null, not a failure.\n */\nexport async function runPrimeExchange<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n): Promise<PrimeExchangeOutcome<TRow>> {\n  const { contract } = options\n  const turns: PrimeTurnRecord[] = []\n  const repair: PrimeRepairState = { attempted: false, succeeded: null }\n\n  const first = await callPrimeTurn(options, options.prompt)\n  if (!first.ok) {\n    return { ok: false, failure: first.failure, usage: mergeTurns(turns), turns, repair }\n  }\n  turns.push({ turn: 'first', usage: first.usage, rawUsage: first.rawUsage })\n\n  let reply = first.content\n  let parsed = extractPrimeJsonObject(reply)\n  let defect = primeReplyDefect(parsed, contract.rowsField)\n\n  if (defect !== null && options.repair) {\n    repair.attempted = true\n    const second = await callPrimeTurn(\n      options,\n      buildPrimeRepairPrompt({\n        defect,\n        previousReply: reply,\n        repairContractLines: contract.repairContractLines,\n      }),\n    )\n    if (!second.ok) {\n      return { ok: false, failure: second.failure, usage: mergeTurns(turns), turns, repair, reply }\n    }\n    turns.push({ turn: 'repair', usage: second.usage, rawUsage: second.rawUsage })\n    reply = second.content\n    parsed = extractPrimeJsonObject(reply)\n    defect = primeReplyDefect(parsed, contract.rowsField)\n    repair.succeeded = defect === null\n  }\n\n  const usage = mergeTurns(turns)\n  if (defect !== null) {\n    return {\n      ok: false,\n      failure: {\n        kind: 'malformed-reply',\n        message: `${defect} in prime reply${repair.attempted ? ' even after the bounded repair turn' : ''}`,\n      },\n      usage,\n      turns,\n      repair,\n      reply,\n    }\n  }\n\n  const rawRows = parsed![contract.rowsField] as unknown[]\n  const { rows, rejected, overflow } = decodeContractRows(contract, rawRows)\n  const answer = parsed!.answer\n  return {\n    ok: true,\n    answer: typeof answer === 'string' ? answer : null,\n    rows,\n    rejected,\n    reportedRows: rawRows.length,\n    overflow,\n    usage,\n    turns,\n    repair,\n    reply,\n  }\n}\n\ntype PrimeTurnOutcome =\n  | { ok: true; content: string; usage: PrimeRawUsage; rawUsage: unknown }\n  | { ok: false; failure: PrimeFailure }\n\nasync function callPrimeTurn<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n  content: string,\n): Promise<PrimeTurnOutcome> {\n  const { transport, url, model, timeoutMs, signal } = options\n  const controller = new AbortController()\n  const forwardAbort = () => controller.abort(signal?.reason)\n  if (signal?.aborted) controller.abort(signal.reason)\n  else signal?.addEventListener('abort', forwardAbort, { once: true })\n  const deadline = setTimeout(() => controller.abort(), timeoutMs)\n  let result: PrimeBridgeTransportResult\n  try {\n    result = await transport({\n      url,\n      body: { model, messages: [{ role: 'user', content }] },\n      signal: controller.signal,\n    })\n  } catch (error) {\n    if (signal?.aborted) {\n      return {\n        ok: false,\n        failure: {\n          kind: 'aborted',\n          message: 'prime exchange cancelled by the caller',\n          cause: error,\n        },\n      }\n    }\n    if (controller.signal.aborted) {\n      return {\n        ok: false,\n        failure: { kind: 'deadline', message: `bridge call exceeded ${timeoutMs}ms` },\n      }\n    }\n    return {\n      ok: false,\n      failure: {\n        kind: 'transport',\n        message: `bridge transport failure: ${error instanceof Error ? error.message : String(error)}`,\n      },\n    }\n  } finally {\n    clearTimeout(deadline)\n    signal?.removeEventListener('abort', forwardAbort)\n  }\n\n  if (result.status !== 200) {\n    const bodySnippet = result.text.slice(0, 500)\n    return {\n      ok: false,\n      failure: {\n        kind: 'http-status',\n        message: `bridge HTTP ${result.status}: ${bodySnippet}`,\n        status: result.status,\n        bodySnippet,\n      },\n    }\n  }\n  let response: unknown\n  try {\n    response = JSON.parse(result.text)\n  } catch {\n    return {\n      ok: false,\n      failure: {\n        kind: 'unparseable-json',\n        message: `bridge returned unparseable JSON (${result.text.length} bytes)`,\n      },\n    }\n  }\n  const replyContent = primeReplyContent(response)\n  if (replyContent === null) {\n    return {\n      ok: false,\n      failure: { kind: 'no-content', message: 'bridge reply carries no message content' },\n    }\n  }\n  const rawUsage = primeReplyUsage(response)\n  return { ok: true, content: replyContent, usage: normalizePrimeUsage(rawUsage), rawUsage }\n}\n\n/**\n * Fold from the FIRST turn, never from an empty receipt: an all-null identity\n * would poison every side it merged with and erase counts the bridge reported.\n */\nfunction mergeTurns(turns: readonly PrimeTurnRecord[]): PrimeRawUsage {\n  if (turns.length === 0) return emptyPrimeRawUsage()\n  return turns\n    .slice(1)\n    .reduce<PrimeRawUsage>((total, turn) => mergePrimeRawUsage(total, turn.usage), turns[0]!.usage)\n}\n\nfunction primeReplyContent(response: unknown): string | null {\n  if (typeof response !== 'object' || response === null) return null\n  const choices = (response as { choices?: unknown }).choices\n  if (!Array.isArray(choices) || choices.length === 0) return null\n  const message = (choices[0] as { message?: unknown })?.message\n  if (typeof message !== 'object' || message === null) return null\n  const content = (message as { content?: unknown }).content\n  return typeof content === 'string' && content.length > 0 ? content : null\n}\n\nfunction primeReplyUsage(response: unknown): unknown {\n  if (typeof response !== 'object' || response === null) return null\n  return (response as { usage?: unknown }).usage ?? null\n}\n\n// ── Trajectory projection ────────────────────────────────────────────\n\n/**\n * Where the inlined trajectory comes from. The protocol needs only two moves —\n * fetch it all, or fetch a reduced version — so no store, artifact path, or\n * span type enters the shared signature.\n */\nexport interface PrimeProjectionSource<TItem> {\n  /** The full projection, or null when the source declares itself oversized. */\n  full(): Promise<readonly TItem[] | null>\n  /** A reduced projection of the same material. */\n  capped(): Promise<readonly TItem[]>\n  /** How `capped` reduces, named for the failure message, e.g. `per-attribute cap 1200`. */\n  cappedDescription: string\n}\n\nexport interface PrimeProjectionDelivery {\n  mode: 'inline-json'\n  fetch: 'full' | 'capped'\n  renderedChars: number\n}\n\nexport type PrimeProjectionOutcome<TItem> =\n  | {\n      ok: true\n      items: readonly TItem[]\n      rendered: string\n      delivery: PrimeProjectionDelivery\n    }\n  | { ok: false; reason: string; renderedChars: number }\n\n/**\n * Render, measure, fall back to the capped projection, re-measure, fail loud.\n *\n * Inline is the only delivery prime has, so an oversized trajectory is a\n * refusal rather than a silent truncation: dropping spans would understate the\n * trajectory and the analyst would answer a question about a different run.\n */\nexport async function projectPrimeTrajectory<TItem>(\n  source: PrimeProjectionSource<TItem>,\n  limits: { maxInlineChars: number },\n): Promise<PrimeProjectionOutcome<TItem>> {\n  let fetch: PrimeProjectionDelivery['fetch'] = 'full'\n  let items = await source.full()\n  if (items === null) {\n    fetch = 'capped'\n    items = await source.capped()\n  }\n  let rendered = JSON.stringify(items)\n  if (rendered.length > limits.maxInlineChars && fetch === 'full') {\n    fetch = 'capped'\n    items = await source.capped()\n    rendered = JSON.stringify(items)\n  }\n  if (rendered.length > limits.maxInlineChars) {\n    return {\n      ok: false,\n      reason: `trajectory renders to ${rendered.length} chars even at ${source.cappedDescription}; inline delivery impossible`,\n      renderedChars: rendered.length,\n    }\n  }\n  return {\n    ok: true,\n    items,\n    rendered,\n    delivery: { mode: 'inline-json', fetch, renderedChars: rendered.length },\n  }\n}\n\n// ── Protocol identity ────────────────────────────────────────────────\n\nexport interface PrimeProtocolIdentity {\n  question: string\n  taskDefinition?: string\n  contractLines: readonly string[]\n  repairContractLines: readonly string[]\n  /** Numeric limits the contract states, e.g. row and width caps. */\n  limits: Readonly<Record<string, number>>\n}\n\n/**\n * Digest of everything a consumer can send to the bridge under the prime\n * protocol, recorded per observation so a prime result names the exact contract\n * that produced it.\n *\n * Computed over the ACTUALLY composed contract, so two consumers that both\n * stamp `analyst_id: 'prime'` while asking materially different questions get\n * different digests by construction. That is what makes 'prime' a reproducible\n * claim rather than a label.\n */\nexport function primeProtocolSha256(identity: PrimeProtocolIdentity): string {\n  return createHash('sha256')\n    .update(\n      JSON.stringify({\n        kind: 'prime-analyst-protocol',\n        question: identity.question,\n        taskPrompt: identity.taskDefinition ?? null,\n        outputContract: identity.contractLines,\n        repairContract: buildPrimeRepairPrompt({\n          defect: '<defect>',\n          previousReply: '<previous-reply>',\n          repairContractLines: identity.repairContractLines,\n        }),\n        limits: identity.limits,\n      }),\n    )\n    .digest('hex')\n}\n"],"mappings":"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"}

package/dist/profile-cell.d.ts

@@ -1,2 +1,2 @@
-import { _ as toAgentProfileJson, a as AgentProfileCellSchemaVersion, c as AgentProfileHarness, d as AgentProfileKind, f as AgentProfileSource, g as groupRunsByAgentProfileCell, h as buildAgentProfileCell, i as AgentProfileCellInput, l as AgentProfileJson, m as agentProfileCellKey, n as AgentInterfaceProfileLike, o as AgentProfileCellValidationError, p as AgentProfileSourceInput, r as AgentProfileCell, s as AgentProfileDimensionValue, t as AGENT_PROFILE_KINDS, u as AgentProfileJsonObject, v as validateAgentProfileCell, y as verifyAgentProfileCell } from "./agent-profile-cell-BcpFbNd5.js";
+import { _ as toAgentProfileJson, a as AgentProfileCellSchemaVersion, c as AgentProfileHarness, d as AgentProfileKind, f as AgentProfileSource, g as groupRunsByAgentProfileCell, h as buildAgentProfileCell, i as AgentProfileCellInput, l as AgentProfileJson, m as agentProfileCellKey, n as AgentInterfaceProfileLike, o as AgentProfileCellValidationError, p as AgentProfileSourceInput, r as AgentProfileCell, s as AgentProfileDimensionValue, t as AGENT_PROFILE_KINDS, u as AgentProfileJsonObject, v as validateAgentProfileCell, y as verifyAgentProfileCell } from "./agent-profile-cell-3kYxUsK2.js";
 export { AGENT_PROFILE_KINDS, AgentInterfaceProfileLike, AgentProfileCell, AgentProfileCellInput, AgentProfileCellSchemaVersion, AgentProfileCellValidationError, AgentProfileDimensionValue, AgentProfileHarness, AgentProfileJson, AgentProfileJsonObject, AgentProfileKind, AgentProfileSource, AgentProfileSourceInput, agentProfileCellKey, buildAgentProfileCell, groupRunsByAgentProfileCell, toAgentProfileJson, validateAgentProfileCell, verifyAgentProfileCell };

package/dist/profile-cell.js

@@ -1,2 +1 @@
-import { a as groupRunsByAgentProfileCell, c as verifyAgentProfileCell, i as buildAgentProfileCell, n as AgentProfileCellValidationError, o as toAgentProfileJson, r as agentProfileCellKey, s as validateAgentProfileCell, t as AGENT_PROFILE_KINDS } from "./agent-profile-cell-B1V1gUZs.js";
-export { AGENT_PROFILE_KINDS, AgentProfileCellValidationError, agentProfileCellKey, buildAgentProfileCell, groupRunsByAgentProfileCell, toAgentProfileJson, validateAgentProfileCell, verifyAgentProfileCell };
+export { t as AGENT_PROFILE_KINDS, n as AgentProfileCellValidationError, r as agentProfileCellKey, i as buildAgentProfileCell, a as groupRunsByAgentProfileCell, o as toAgentProfileJson, s as validateAgentProfileCell, c as verifyAgentProfileCell } from "./agent-profile-cell-CT5JYueM.js";

package/dist/{promotion-gate-CkVZHagC.d.ts → promotion-gate-CixshGI8.d.ts}

@@ -1,8 +1,7 @@
-import { o as FailureClass } from "./schema-D6EVKzTB.js";
-import { a as RunRecord, c as RunSplitTag } from "./run-record-C3awiXPf.js";
-import { i as DatasetSplit, n as DatasetManifest, r as DatasetScenario } from "./dataset-DQqhOCPt.js";
-import { S as HeldOutGateDecision } from "./summary-report-C8V49Jt3.js";
-//#region src/statistics/rank-tests.d.ts
+import { o as FailureClass } from "./schema-CkIvnmLU.js";
+import { a as RunRecord, c as RunSplitTag } from "./run-record-D2BFMPGl.js";
+import { i as DatasetSplit, n as DatasetManifest, r as DatasetScenario } from "./dataset-DThC1S6G.js";
+import { S as HeldOutGateDecision } from "./summary-report-0La5vejY.js";
 /** How a rank test's p-value was actually computed. */
 type RankTestMethod = 'exact' | 'permutation' | 'asymptotic';
 /**
@@ -71,8 +70,6 @@ interface WilcoxonSignedRankResult {
  * `pFloor` states rather than leaving `p = 1` to be read as a measured null.
  */
 declare function wilcoxonSignedRank(before: number[], after: number[], opts?: RankTestOptions): WilcoxonSignedRankResult;
-//#endregion
-//#region src/release-confidence.d.ts
 /** Severity of an actionable finding attached to a run/trace. */
 type AsiSeverity = 'info' | 'warning' | 'error' | 'critical';
 /** Actionable side-info — a diagnosed finding the loop can act on. */
@@ -201,8 +198,6 @@ interface ReleaseConfidenceScorecard {
   summary: string;
 }
 declare function evaluateReleaseConfidence(input: ReleaseConfidenceInput): ReleaseConfidenceScorecard;
-//#endregion
-//#region src/promotion-gate.d.ts
 /**
  * Bootstrap-CI promotion gate.
  *
@@ -299,6 +294,5 @@ declare function judgeReplayGate<TOutput>(args: JudgeReplayGateArgs<TOutput>): P
   baselineSamples: number;
   candidateSamples: number;
 }>;
-//#endregion
 export { mannWhitneyU as C, WilcoxonSignedRankResult as S, evaluateReleaseConfidence as _, bootstrapCi as a, RankTestMethodRequest as b, ReleaseConfidenceAxis as c, ReleaseConfidenceIssue as d, ReleaseConfidenceMetrics as f, ReleaseTraceEvidence as g, ReleaseConfidenceThresholds as h, Verdict as i, ReleaseConfidenceAxisName as l, ReleaseConfidenceStatus as m, BootstrapResult as n, judgeReplayGate as o, ReleaseConfidenceScorecard as p, JudgeReplayGateArgs as r, ActionableSideInfo as s, BootstrapOptions as t, ReleaseConfidenceInput as u, MannWhitneyResult as v, wilcoxonSignedRank as w, RankTestOptions as x, RankTestMethod as y };
-//# sourceMappingURL=promotion-gate-CkVZHagC.d.ts.map
+//# sourceMappingURL=promotion-gate-CixshGI8.d.ts.map

package/dist/promotion-gate-CixshGI8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promotion-gate-CixshGI8.d.ts","names":[],"sources":["../src/statistics/rank-tests.ts","../src/release-confidence.ts","../src/promotion-gate.ts"],"mappings":";;;;;KAiCY;;;;;KAMA;UAEK;;EAEf,SAAS;;EAET;;;EAGA;;UAYe;;EAEf;;EAEA;;EAEA;;EAEA,QAAQ;;EAER;;;;;;;;;;;;;;iBAec,aACd,aACA,aACA,OAAM,kBACL;UAuFc;;;EAGf;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;;;;;;;;;;;;;;;iBAgBc,mBACd,kBACA,iBACA,OAAM,kBACL;;KCxLE;;UAGY;;EAEf;;EAEA;EACA,WAAW;;EAEX;;EAEA;;EAEA;;EAEA;EACA,WAAW;;KAGD;KACA;UAQK;EACf;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA;EACA;;EAEA,eAAe;EACf,MAAM;EACN,WAAW;;UAGI;;EAEf;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,UAAU;EACV,qBAAqB;EACrB,gBAAgB;EAChB,kBAAkB;EAClB,eAAe;EACf,aAAa;;UAGE;EACf,MAAM;EACN,QAAQ;EACR;EACA;;UAGe;EACf,MAAM;EACN;EACA;EACA;;UAGe;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa,OAAO;EACpB,cAAc;EACd,oBAAoB,QAAQ,OAAO;EACnC,0BAA0B;;;;;;;EAO1B;;UAGe;EACf;EACA;EACA;EACA,QAAQ;EACR;EACA,MAAM;EACN,QAAQ;EACR,SAAS;EACT,SAAS;EACT,cAAc;EACd;;iBAkBc,0BACd,OAAO,yBACN;;;;;;;;;;;;;;;;;;;;;;;;;KC3JS;UAEK;EACf;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,SAAS;;UAGM;;EAEf;;EAEA;;;;;;EAMA;;;EAGA;;;;;;;;;iBAUc,YACd,oBACA,qBACA,UAAS,mBACR;;;;;;;;;;;;;;;;UA0Gc,oBAAoB;EACnC,iBAAiB;EACjB,kBAAkB;;EAElB,QAAQ,QAAQ,YAAY;EAC5B;EACA;;EAEA;;EAEA;;;;;iBAMoB,gBAAgB,SACpC,MAAM,oBAAoB,WACzB,QAAQ;EAAoB;EAAyB"}