@tangle-network/agent-eval 0.216.1 → 0.217.1

package/dist/{types-B3jzCp0p.js → types-BXgASBCL.js}

@@ -103,6 +103,6 @@ function describeValue(value) {
 	return `${typeof value} ${String(value)}`;
 }
 //#endregion
-export { assertMultishotShotResult as i, MultishotFatalToolError as n, MultishotShotResultError as r, MultishotDriverEmptyError as t };
+export { MultishotFatalToolError as n, assertMultishotShotResult as r, MultishotDriverEmptyError as t };
 
-//# sourceMappingURL=types-B3jzCp0p.js.map
+//# sourceMappingURL=types-BXgASBCL.js.map

package/dist/{types-B3jzCp0p.js.map → types-BXgASBCL.js.map}

@@ -1 +1 @@
-{"version":3,"file":"types-B3jzCp0p.js","names":[],"sources":["../src/multishot/types.ts"],"sourcesContent":["// Public types for the multishot substrate.\n\nimport type { CostProvenance } from '../cost-ledger'\n\nexport interface MultishotMessage {\n  role: 'user' | 'assistant' | 'tool'\n  content: string\n  toolCallId?: string\n  toolCalls?: Array<{ id: string; name: string; args: Record<string, unknown> }>\n}\n\nexport interface MultishotArtifact {\n  type: string\n  turn: number\n  invocation: { name: string; args: Record<string, unknown> }\n  content: string\n}\n\nexport interface MultishotResult {\n  transcript: MultishotMessage[]\n  artifacts: MultishotArtifact[]\n  toolCalls: number\n  durationMs: number\n  /** Known spend. A subtotal, not a total, when `costProvenance.kind` is\n   *  `uncaptured`. */\n  costUsd: number\n  /** Origin of `costUsd`. A shot that priced every call reports `estimated`\n   *  or `observed`; a shot with a call the router priced at nothing reports\n   *  `uncaptured`, and the matrix records the cell as under-counted instead of\n   *  presenting the subtotal as a complete estimate.\n   *\n   *  Optional so an engine written before this field keeps working; the matrix\n   *  then judges the cell on judge receipts alone, as it did before. */\n  costProvenance?: CostProvenance\n}\n\nexport interface MultishotToolDefinition {\n  type: 'function'\n  function: {\n    name: string\n    description: string\n    parameters: Record<string, unknown>\n  }\n}\n\n/** One chat-completion request the multishot loop issues for a single agent\n *  (or driver) inference step. Mirrors the OpenAI-compat body the loop would\n *  otherwise POST to the Tangle router. */\nexport interface MultishotTransportRequest {\n  model: string\n  messages: Array<Record<string, unknown>>\n  tools?: MultishotToolDefinition[]\n  temperature?: number\n  maxTokens?: number\n  signal?: AbortSignal\n}\n\nexport interface MultishotTransportToolCall {\n  id: string\n  type: 'function'\n  function: { name: string; arguments: string }\n}\n\nexport interface MultishotTransportResponse {\n  message: { content?: string | null; tool_calls?: MultishotTransportToolCall[] }\n  usage?: { prompt_tokens?: number; completion_tokens?: number }\n  /** Actual spend for this call. When omitted, the loop meters cost from\n   *  `usage` via the per-model estimator (estimateMultishotCost). */\n  costUsd?: number\n  /** Model identity the provider reported, when the transport observed one.\n   *  Omitted means unreported, and the requested model is used for\n   *  attribution — which is not proof that model answered. */\n  model?: string\n}\n\n/** Execution seam for one leg of the multishot loop. The caller owns model\n *  execution: agent-eval issues no provider request and holds no credential.\n *  The loop still owns turn scheduling, tool dispatch, transcript capture, and\n *  cost metering. agent-eval has no dependency on agent-runtime; adapt\n *  agent-runtime's `profileChatClient` (or any sandbox, bridge, or router\n *  client) into this signature product-side. */\nexport type MultishotTransport = (\n  req: MultishotTransportRequest,\n) => Promise<MultishotTransportResponse>\n\nexport type MultishotToolExecutor = (\n  args: Record<string, unknown>,\n  ctx: {\n    /** Caller-owned execution seam for the specialist leg this tool runs. */\n    transport: MultishotTransport\n    signal?: AbortSignal\n  },\n) => Promise<{ content: string; costUsd: number }>\n\nexport interface MultishotPersona {\n  /** Stable identifier — used for per-cell artifact paths + matrix axis keys. */\n  id: string\n  /** Per-domain payload (income/profile/voice/etc.) shaped by the consumer. */\n  [k: string]: unknown\n}\n\n/**\n * Persona-shaping callbacks. Both are OPTIONAL: when omitted, the loop derives\n * them from the `AgentProfile` + persona payload (see `defaultShapeFromProfile`)\n * so a pure-profile call — `runMultishot({ profile, persona })` — works with no\n * role-builder functions. Provide callbacks only to override the derived shape.\n */\nexport interface MultishotShape<TPersona extends MultishotPersona> {\n  /** Opening user message (turn 0) — the persona's first ask. */\n  buildOpener?: (persona: TPersona) => string\n  /** System prompt the driver LLM uses to roleplay the persona. Should set\n   *  voice, goals, constraints, time-pressure, and the \"never go silent\" rule. */\n  buildDriverSystemPrompt?: (persona: TPersona) => string\n}\n\nexport class MultishotDriverEmptyError extends Error {\n  constructor(public readonly turn: number) {\n    super(`multishot: driver returned empty content twice at turn ${turn} — failing loud`)\n    this.name = 'MultishotDriverEmptyError'\n  }\n}\n\nexport class MultishotFatalToolError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'MultishotFatalToolError'\n  }\n}\n\nexport class MultishotShotResultError extends Error {\n  constructor(reason: string) {\n    super(`multishot: shot returned an invalid MultishotResult — ${reason}`)\n    this.name = 'MultishotShotResultError'\n  }\n}\n\nconst MULTISHOT_ROLES = new Set(['user', 'assistant', 'tool'])\n\n/** Contract guard for the value a caller-supplied shot resolves with. The\n *  matrix writes per-cell artifacts, builds judge inputs, and meters cost from\n *  this value, so a malformed result must stop the cell instead of scoring a\n *  degraded one. Two silent degradations this closes: an artifact with no\n *  `type` matches neither the code nor the content artifact set, so the cell\n *  scores as though the artifact was never produced; a non-finite `costUsd`\n *  reaches `summary.totalCostUsd` and makes every cost number NaN.\n *\n *  A rejected cell is still billed: the matrix cell reads the shot's own\n *  `costUsd` when it is a usable amount and declares that spend on the throw,\n *  so money the shot spent before returning a malformed result stays in the\n *  cumulative sum the cost ceiling reads. A result whose `costUsd` is itself\n *  malformed carries no usable amount, and the cell records as `uncaptured`.\n *\n *  Every required field of `MultishotMessage` and `MultishotArtifact` is\n *  checked, including `toolCalls` elements and `invocation.args`. Optional\n *  fields are checked only when present. */\nexport function assertMultishotShotResult(value: unknown): asserts value is MultishotResult {\n  if (typeof value !== 'object' || value === null) {\n    throw new MultishotShotResultError(`expected an object, received ${describeValue(value)}`)\n  }\n  const result = value as Record<string, unknown>\n  if (!Array.isArray(result.transcript)) {\n    throw new MultishotShotResultError(\n      `transcript must be an array, received ${describeValue(result.transcript)}`,\n    )\n  }\n  if (!Array.isArray(result.artifacts)) {\n    throw new MultishotShotResultError(\n      `artifacts must be an array, received ${describeValue(result.artifacts)}`,\n    )\n  }\n  result.transcript.forEach(assertMessage)\n  result.artifacts.forEach(assertArtifact)\n  assertFiniteCount(result.toolCalls, 'toolCalls')\n  assertFiniteCount(result.durationMs, 'durationMs')\n  assertFiniteCount(result.costUsd, 'costUsd')\n  if (result.costProvenance !== undefined) assertCostProvenance(result.costProvenance)\n}\n\nfunction assertCostProvenance(value: unknown): void {\n  const row = requireRow(value, 'costProvenance')\n  if (row.kind !== 'observed' && row.kind !== 'estimated' && row.kind !== 'uncaptured') {\n    throw new MultishotShotResultError(\n      `costProvenance.kind must be observed, estimated or uncaptured, received ${describeValue(row.kind)}`,\n    )\n  }\n  // The matrix reads the amount from `costUsd`; `usd` only has to agree with\n  // the kind, so an uncaptured provenance cannot smuggle in a total.\n  if (row.kind === 'uncaptured') {\n    if (row.usd !== null) {\n      throw new MultishotShotResultError(\n        `uncaptured costProvenance.usd must be null, received ${describeValue(row.usd)}`,\n      )\n    }\n    return\n  }\n  assertFiniteCount(row.usd, 'costProvenance.usd')\n}\n\nfunction assertMessage(value: unknown, index: number): void {\n  const row = requireRow(value, `transcript[${index}]`)\n  if (typeof row.role !== 'string' || !MULTISHOT_ROLES.has(row.role)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].role must be user, assistant or tool, received ${describeValue(row.role)}`,\n    )\n  }\n  assertString(row.content, `transcript[${index}].content`)\n  if (row.toolCallId !== undefined) {\n    assertString(row.toolCallId, `transcript[${index}].toolCallId`)\n  }\n  if (row.toolCalls === undefined) return\n  if (!Array.isArray(row.toolCalls)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].toolCalls must be an array when present, received ${describeValue(row.toolCalls)}`,\n    )\n  }\n  row.toolCalls.forEach((call, callIndex) => {\n    const field = `transcript[${index}].toolCalls[${callIndex}]`\n    const row = requireRow(call, field)\n    assertString(row.id, `${field}.id`)\n    assertString(row.name, `${field}.name`)\n    requireRow(row.args, `${field}.args`)\n  })\n}\n\nfunction assertArtifact(value: unknown, index: number): void {\n  const row = requireRow(value, `artifacts[${index}]`)\n  assertString(row.type, `artifacts[${index}].type`)\n  assertString(row.content, `artifacts[${index}].content`)\n  assertFiniteCount(row.turn, `artifacts[${index}].turn`)\n  const invocation = requireRow(row.invocation, `artifacts[${index}].invocation`)\n  assertString(invocation.name, `artifacts[${index}].invocation.name`)\n  requireRow(invocation.args, `artifacts[${index}].invocation.args`)\n}\n\nfunction requireRow(value: unknown, field: string): Record<string, unknown> {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    throw new MultishotShotResultError(\n      `${field} must be an object, received ${describeValue(value)}`,\n    )\n  }\n  return value as Record<string, unknown>\n}\n\nfunction assertString(value: unknown, field: string): void {\n  if (typeof value !== 'string') {\n    throw new MultishotShotResultError(\n      `${field} must be a string, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction assertFiniteCount(value: unknown, field: string): void {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {\n    throw new MultishotShotResultError(\n      `${field} must be a finite number >= 0, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction describeValue(value: unknown): string {\n  if (value === null) return 'null'\n  if (Array.isArray(value)) return 'an array'\n  if (typeof value === 'object') return 'an object'\n  return `${typeof value} ${String(value)}`\n}\n"],"mappings":"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"}
+{"version":3,"file":"types-BXgASBCL.js","names":[],"sources":["../src/multishot/types.ts"],"sourcesContent":["// Public types for the multishot substrate.\n\nimport type { CostProvenance } from '../cost-ledger'\n\nexport interface MultishotMessage {\n  role: 'user' | 'assistant' | 'tool'\n  content: string\n  toolCallId?: string\n  toolCalls?: Array<{ id: string; name: string; args: Record<string, unknown> }>\n}\n\nexport interface MultishotArtifact {\n  type: string\n  turn: number\n  invocation: { name: string; args: Record<string, unknown> }\n  content: string\n}\n\nexport interface MultishotResult {\n  transcript: MultishotMessage[]\n  artifacts: MultishotArtifact[]\n  toolCalls: number\n  durationMs: number\n  /** Known spend. A subtotal, not a total, when `costProvenance.kind` is\n   *  `uncaptured`. */\n  costUsd: number\n  /** Origin of `costUsd`. A shot that priced every call reports `estimated`\n   *  or `observed`; a shot with a call the router priced at nothing reports\n   *  `uncaptured`, and the matrix records the cell as under-counted instead of\n   *  presenting the subtotal as a complete estimate.\n   *\n   *  Optional so an engine written before this field keeps working; the matrix\n   *  then judges the cell on judge receipts alone, as it did before. */\n  costProvenance?: CostProvenance\n}\n\nexport interface MultishotToolDefinition {\n  type: 'function'\n  function: {\n    name: string\n    description: string\n    parameters: Record<string, unknown>\n  }\n}\n\n/** One chat-completion request the multishot loop issues for a single agent\n *  (or driver) inference step. Mirrors the OpenAI-compat body the loop would\n *  otherwise POST to the Tangle router. */\nexport interface MultishotTransportRequest {\n  model: string\n  messages: Array<Record<string, unknown>>\n  tools?: MultishotToolDefinition[]\n  temperature?: number\n  maxTokens?: number\n  signal?: AbortSignal\n}\n\nexport interface MultishotTransportToolCall {\n  id: string\n  type: 'function'\n  function: { name: string; arguments: string }\n}\n\nexport interface MultishotTransportResponse {\n  message: { content?: string | null; tool_calls?: MultishotTransportToolCall[] }\n  usage?: { prompt_tokens?: number; completion_tokens?: number }\n  /** Actual spend for this call. When omitted, the loop meters cost from\n   *  `usage` via the per-model estimator (estimateMultishotCost). */\n  costUsd?: number\n  /** Model identity the provider reported, when the transport observed one.\n   *  Omitted means unreported, and the requested model is used for\n   *  attribution — which is not proof that model answered. */\n  model?: string\n}\n\n/** Execution seam for one leg of the multishot loop. The caller owns model\n *  execution: agent-eval issues no provider request and holds no credential.\n *  The loop still owns turn scheduling, tool dispatch, transcript capture, and\n *  cost metering. agent-eval has no dependency on agent-runtime; adapt\n *  agent-runtime's `profileChatClient` (or any sandbox, bridge, or router\n *  client) into this signature product-side. */\nexport type MultishotTransport = (\n  req: MultishotTransportRequest,\n) => Promise<MultishotTransportResponse>\n\nexport type MultishotToolExecutor = (\n  args: Record<string, unknown>,\n  ctx: {\n    /** Caller-owned execution seam for the specialist leg this tool runs. */\n    transport: MultishotTransport\n    signal?: AbortSignal\n  },\n) => Promise<{ content: string; costUsd: number }>\n\nexport interface MultishotPersona {\n  /** Stable identifier — used for per-cell artifact paths + matrix axis keys. */\n  id: string\n  /** Per-domain payload (income/profile/voice/etc.) shaped by the consumer. */\n  [k: string]: unknown\n}\n\n/**\n * Persona-shaping callbacks. Both are OPTIONAL: when omitted, the loop derives\n * them from the `AgentProfile` + persona payload (see `defaultShapeFromProfile`)\n * so a pure-profile call — `runMultishot({ profile, persona })` — works with no\n * role-builder functions. Provide callbacks only to override the derived shape.\n */\nexport interface MultishotShape<TPersona extends MultishotPersona> {\n  /** Opening user message (turn 0) — the persona's first ask. */\n  buildOpener?: (persona: TPersona) => string\n  /** System prompt the driver LLM uses to roleplay the persona. Should set\n   *  voice, goals, constraints, time-pressure, and the \"never go silent\" rule. */\n  buildDriverSystemPrompt?: (persona: TPersona) => string\n}\n\nexport class MultishotDriverEmptyError extends Error {\n  constructor(public readonly turn: number) {\n    super(`multishot: driver returned empty content twice at turn ${turn} — failing loud`)\n    this.name = 'MultishotDriverEmptyError'\n  }\n}\n\nexport class MultishotFatalToolError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'MultishotFatalToolError'\n  }\n}\n\nexport class MultishotShotResultError extends Error {\n  constructor(reason: string) {\n    super(`multishot: shot returned an invalid MultishotResult — ${reason}`)\n    this.name = 'MultishotShotResultError'\n  }\n}\n\nconst MULTISHOT_ROLES = new Set(['user', 'assistant', 'tool'])\n\n/** Contract guard for the value a caller-supplied shot resolves with. The\n *  matrix writes per-cell artifacts, builds judge inputs, and meters cost from\n *  this value, so a malformed result must stop the cell instead of scoring a\n *  degraded one. Two silent degradations this closes: an artifact with no\n *  `type` matches neither the code nor the content artifact set, so the cell\n *  scores as though the artifact was never produced; a non-finite `costUsd`\n *  reaches `summary.totalCostUsd` and makes every cost number NaN.\n *\n *  A rejected cell is still billed: the matrix cell reads the shot's own\n *  `costUsd` when it is a usable amount and declares that spend on the throw,\n *  so money the shot spent before returning a malformed result stays in the\n *  cumulative sum the cost ceiling reads. A result whose `costUsd` is itself\n *  malformed carries no usable amount, and the cell records as `uncaptured`.\n *\n *  Every required field of `MultishotMessage` and `MultishotArtifact` is\n *  checked, including `toolCalls` elements and `invocation.args`. Optional\n *  fields are checked only when present. */\nexport function assertMultishotShotResult(value: unknown): asserts value is MultishotResult {\n  if (typeof value !== 'object' || value === null) {\n    throw new MultishotShotResultError(`expected an object, received ${describeValue(value)}`)\n  }\n  const result = value as Record<string, unknown>\n  if (!Array.isArray(result.transcript)) {\n    throw new MultishotShotResultError(\n      `transcript must be an array, received ${describeValue(result.transcript)}`,\n    )\n  }\n  if (!Array.isArray(result.artifacts)) {\n    throw new MultishotShotResultError(\n      `artifacts must be an array, received ${describeValue(result.artifacts)}`,\n    )\n  }\n  result.transcript.forEach(assertMessage)\n  result.artifacts.forEach(assertArtifact)\n  assertFiniteCount(result.toolCalls, 'toolCalls')\n  assertFiniteCount(result.durationMs, 'durationMs')\n  assertFiniteCount(result.costUsd, 'costUsd')\n  if (result.costProvenance !== undefined) assertCostProvenance(result.costProvenance)\n}\n\nfunction assertCostProvenance(value: unknown): void {\n  const row = requireRow(value, 'costProvenance')\n  if (row.kind !== 'observed' && row.kind !== 'estimated' && row.kind !== 'uncaptured') {\n    throw new MultishotShotResultError(\n      `costProvenance.kind must be observed, estimated or uncaptured, received ${describeValue(row.kind)}`,\n    )\n  }\n  // The matrix reads the amount from `costUsd`; `usd` only has to agree with\n  // the kind, so an uncaptured provenance cannot smuggle in a total.\n  if (row.kind === 'uncaptured') {\n    if (row.usd !== null) {\n      throw new MultishotShotResultError(\n        `uncaptured costProvenance.usd must be null, received ${describeValue(row.usd)}`,\n      )\n    }\n    return\n  }\n  assertFiniteCount(row.usd, 'costProvenance.usd')\n}\n\nfunction assertMessage(value: unknown, index: number): void {\n  const row = requireRow(value, `transcript[${index}]`)\n  if (typeof row.role !== 'string' || !MULTISHOT_ROLES.has(row.role)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].role must be user, assistant or tool, received ${describeValue(row.role)}`,\n    )\n  }\n  assertString(row.content, `transcript[${index}].content`)\n  if (row.toolCallId !== undefined) {\n    assertString(row.toolCallId, `transcript[${index}].toolCallId`)\n  }\n  if (row.toolCalls === undefined) return\n  if (!Array.isArray(row.toolCalls)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].toolCalls must be an array when present, received ${describeValue(row.toolCalls)}`,\n    )\n  }\n  row.toolCalls.forEach((call, callIndex) => {\n    const field = `transcript[${index}].toolCalls[${callIndex}]`\n    const row = requireRow(call, field)\n    assertString(row.id, `${field}.id`)\n    assertString(row.name, `${field}.name`)\n    requireRow(row.args, `${field}.args`)\n  })\n}\n\nfunction assertArtifact(value: unknown, index: number): void {\n  const row = requireRow(value, `artifacts[${index}]`)\n  assertString(row.type, `artifacts[${index}].type`)\n  assertString(row.content, `artifacts[${index}].content`)\n  assertFiniteCount(row.turn, `artifacts[${index}].turn`)\n  const invocation = requireRow(row.invocation, `artifacts[${index}].invocation`)\n  assertString(invocation.name, `artifacts[${index}].invocation.name`)\n  requireRow(invocation.args, `artifacts[${index}].invocation.args`)\n}\n\nfunction requireRow(value: unknown, field: string): Record<string, unknown> {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    throw new MultishotShotResultError(\n      `${field} must be an object, received ${describeValue(value)}`,\n    )\n  }\n  return value as Record<string, unknown>\n}\n\nfunction assertString(value: unknown, field: string): void {\n  if (typeof value !== 'string') {\n    throw new MultishotShotResultError(\n      `${field} must be a string, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction assertFiniteCount(value: unknown, field: string): void {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {\n    throw new MultishotShotResultError(\n      `${field} must be a finite number >= 0, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction describeValue(value: unknown): string {\n  if (value === null) return 'null'\n  if (Array.isArray(value)) return 'an array'\n  if (typeof value === 'object') return 'an object'\n  return `${typeof value} ${String(value)}`\n}\n"],"mappings":"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"}

package/dist/{types-C1tnkEgM.d.ts → types-CW8ewATZ.d.ts}

@@ -1,6 +1,6 @@
 import { a as CostLedgerHandle, l as CostProvenance } from "./cost-ledger-Jk62OBfF.js";
-import { a as RunRecord, d as RunTokenUsage } from "./run-record-C1E24G2A.js";
-import { c as JudgeInput, x as ChatClient } from "./types-C02qtnG8.js";
+import { a as RunRecord, d as RunTokenUsage } from "./run-record-CaxbLq6Y.js";
+import { l as JudgeInput, x as ChatClient } from "./types-D-mgRzlh.js";
 import { z } from "zod";
 import { SpanKind } from "@tangle-network/agent-trace-contract";
 import { RE2JS } from "re2js";
@@ -185,9 +185,6 @@ interface TraceAnalystByteBudgets {
   perMatchTextBudget: number;
 }
 declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
-/** Marker substituted in place of truncated string payloads. Callers
- *  parsing tool output can detect it deterministically. */
-declare const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
 //#endregion
 //#region src/trace-analyst/store-contract.d.ts
 declare const TRACE_ANALYSIS_LIMITS: {
@@ -298,8 +295,6 @@ declare function createBoundedTraceAnalysisStore(source: TraceAnalysisStore, opt
  */
 declare const FINDING_LAYERS: readonly ['event', 'turn', 'agent', 'team', 'run', 'play', 'problem', 'domain', 'lab', 'meta'];
 type FindingLayer = (typeof FINDING_LAYERS)[number];
-/** Rank on the ladder; `meta` has none. */
-declare function findingLayerRank(layer: FindingLayer): number | null;
 interface FindingScope {
   /**
    * Ids of the measured units. A population is stored resolved, never as a
@@ -352,104 +347,6 @@ interface FindingEvidenceUnit {
   layer: FindingLayer;
   derived_from?: string | null;
 }
-/** The one validator for stored findings of either schema version. Unknown fields fail. */
-declare const AnalystFindingSchema: z.ZodObject<{
-  schema_version: z.ZodEnum<{
-    "1.0.0": "1.0.0";
-    "1.1.0": "1.1.0";
-  }>;
-  finding_id: z.ZodString;
-  analyst_id: z.ZodString;
-  produced_at: z.ZodString;
-  severity: z.ZodEnum<{
-    critical: "critical";
-    high: "high";
-    info: "info";
-    low: "low";
-    medium: "medium";
-  }>;
-  area: z.ZodString;
-  claim: z.ZodString;
-  rationale: z.ZodOptional<z.ZodString>;
-  evidence_refs: z.ZodArray<z.ZodObject<{
-    kind: z.ZodEnum<{
-      artifact: "artifact";
-      event: "event";
-      finding: "finding";
-      metric: "metric";
-      span: "span";
-    }>;
-    uri: z.ZodString;
-    excerpt: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>>;
-  recommended_action: z.ZodOptional<z.ZodString>;
-  validation_plan: z.ZodOptional<z.ZodString>;
-  confidence: z.ZodNumber;
-  subject: z.ZodOptional<z.ZodString>;
-  derived_from_judge: z.ZodOptional<z.ZodBoolean>;
-  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  layer: z.ZodOptional<z.ZodEnum<{
-    agent: "agent";
-    domain: "domain";
-    event: "event";
-    lab: "lab";
-    meta: "meta";
-    play: "play";
-    problem: "problem";
-    run: "run";
-    team: "team";
-    turn: "turn";
-  }>>;
-  scope: z.ZodOptional<z.ZodObject<{
-    population: z.ZodArray<z.ZodString>;
-    n: z.ZodNumber;
-    window: z.ZodObject<{
-      from: z.ZodString;
-      to: z.ZodString;
-    }, z.core.$strict>;
-    domain_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  }, z.core.$strict>>;
-  method: z.ZodOptional<z.ZodObject<{
-    kind: z.ZodEnum<{
-      computed: "computed";
-      judged: "judged";
-      measured: "measured";
-    }>;
-    name: z.ZodString;
-    version: z.ZodString;
-    calibration: z.ZodOptional<z.ZodObject<{
-      gold_n: z.ZodNumber;
-      agreement: z.ZodNumber;
-      kappa: z.ZodNumber;
-    }, z.core.$strict>>;
-  }, z.core.$strict>>;
-  measure: z.ZodOptional<z.ZodObject<{
-    name: z.ZodString;
-    value: z.ZodNumber;
-    unit: z.ZodString;
-    interval: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
-    level: z.ZodOptional<z.ZodNumber>;
-  }, z.core.$strict>>;
-  confounders: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  valid_for: z.ZodOptional<z.ZodString>;
-  claim_id: z.ZodOptional<z.ZodString>;
-  evidence_units: z.ZodOptional<z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    layer: z.ZodEnum<{
-      agent: "agent";
-      domain: "domain";
-      event: "event";
-      lab: "lab";
-      meta: "meta";
-      play: "play";
-      problem: "problem";
-      run: "run";
-      team: "team";
-      turn: "turn";
-    }>;
-    derived_from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-  }, z.core.$strict>>>;
-}, z.core.$strict>;
 /** A finding admitted as candidate-generation input; same rules plus its origin. */
 declare const ProposalFindingSchema: z.ZodObject<{
   schema_version: z.ZodEnum<{
@@ -584,8 +481,6 @@ interface FindingScopeReading {
  */
 type FindingReaderLabel = 'unscoped' | 'anecdote' | 'uncalibrated' | 'lineage-unknown';
 declare function readFindingScope(finding: AnalystFinding): FindingScopeReading;
-/** Root token shared by every unit whose lineage was not recorded. */
-declare const UNKNOWN_LINEAGE = "?unknown-lineage";
 /**
  * Lineage root of each unit, keyed by unit id. A unit derived from another
  * unit in the list shares that unit's root; a unit derived from an id outside
@@ -594,8 +489,6 @@ declare const UNKNOWN_LINEAGE = "?unknown-lineage";
 declare function lineageRoots(units: ReadonlyArray<FindingEvidenceUnit>): Map<string, string>;
 /** Units with distinct lineage roots. */
 declare function independentUnitCount(units: ReadonlyArray<FindingEvidenceUnit>): number;
-/** One entry per unit id, sorted; a later copy that records lineage fills an earlier unknown. */
-declare function mergeEvidenceUnits(units: readonly FindingEvidenceUnit[]): FindingEvidenceUnit[];
 //#endregion
 //#region src/analyst/types.d.ts
 /**
@@ -888,8 +781,6 @@ declare function computeFindingId(input: {
   /** Override the claim for hashing — use when the displayed claim has run-specific bits. */
   id_basis?: string;
 }): string;
-/** Fields that exist only in schema 1.1.0. */
-declare const FINDING_SCOPE_FIELDS: readonly ["layer", "scope", "method", "measure", "confounders", "valid_for", "claim_id", "evidence_units"];
 /**
  * Convenience factory: produce a fully-formed AnalystFinding with the
  * id computed automatically. Analyst code stays terse.
@@ -970,5 +861,5 @@ type AnalystRunEvent = {
   result: AnalystRunResult;
 };
 //#endregion
-export { DatasetOverview as $, FindingMeasure as A, lineageRoots as B, makeFinding as C, FindingCalibration as D, FINDING_LAYERS as E, FindingScopeReading as F, BoundedTraceAnalysisStoreOptions as G, parseAnalystFinding as H, ProposalFindingSchema as I, SpanSourceReader as J, ReadSpanSourceInput as K, UNKNOWN_LINEAGE as L, FindingParseOutcome as M, FindingReaderLabel as N, FindingEvidenceUnit as O, FindingScope as P, DEFAULT_TRACE_ANALYST_BUDGETS as Q, findingLayerRank as R, computeFindingId as S, AnalystFindingSchema as T, readFindingScope as U, mergeEvidenceUnits as V, createBoundedTraceAnalysisStore as W, TraceAnalysisStore as X, TRACE_ANALYSIS_LIMITS as Y, TraceAnalysisStoreContext as Z, ExecutionProbeOutcome as _, AnalystFinding as a, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as at, ProposalFinding as b, AnalystRequirements as c, TraceAnalystSpan as ct, AnalystRunResult as d, TraceAnalystTraceSummary as dt, ErrorCluster as et, AnalystRunSummary as f, ViewSpansResult as ft, ExecutionProbe as g, EvidenceRef as h, AnalystCost as i, SpanMatchRecord as it, FindingMethod as j, FindingLayer as k, AnalystRunEvent as l, TraceAnalystSpanKind as lt, AnalystUsageReceipt as m, ViewTraceResult as mt, Analyst as n, SearchSpanResult as nt, AnalystFindingSchemaVersion as o, TraceAnalystByteBudgets as ot, AnalystSeverity as p, ViewTraceOversized as pt, ReadSpanSourceResult as q, AnalystContext as r, SearchTraceResult as rt, AnalystInputKind as s, TraceAnalystFilters as st, ANALYST_FINDING_SCHEMA_VERSIONS as t, QueryTracesPage as tt, AnalystRunInputs as u, TraceAnalystSpanStatus as ut, ExecutionProbeRequest as v, makeProposalFinding as w, ProposalFindingOrigin as x, FINDING_SCOPE_FIELDS as y, independentUnitCount as z };
-//# sourceMappingURL=types-C1tnkEgM.d.ts.map
+export { TraceAnalystByteBudgets as $, FindingReaderLabel as A, ReadSpanSourceInput as B, FINDING_LAYERS as C, FindingMeasure as D, FindingLayer as E, lineageRoots as F, TraceAnalysisStoreContext as G, SpanSourceReader as H, parseAnalystFinding as I, ErrorCluster as J, DEFAULT_TRACE_ANALYST_BUDGETS as K, readFindingScope as L, FindingScopeReading as M, ProposalFindingSchema as N, FindingMethod as O, independentUnitCount as P, SpanMatchRecord as Q, createBoundedTraceAnalysisStore as R, makeProposalFinding as S, FindingEvidenceUnit as T, TRACE_ANALYSIS_LIMITS as U, ReadSpanSourceResult as V, TraceAnalysisStore as W, SearchSpanResult as X, QueryTracesPage as Y, SearchTraceResult as Z, ExecutionProbeRequest as _, AnalystFindingSchemaVersion as a, ViewSpansResult as at, computeFindingId as b, AnalystRunEvent as c, AnalystRunSummary as d, TraceAnalystFilters as et, AnalystSeverity as f, ExecutionProbeOutcome as g, ExecutionProbe as h, AnalystFinding as i, TraceAnalystTraceSummary as it, FindingScope as j, FindingParseOutcome as k, AnalystRunInputs as l, EvidenceRef as m, AnalystContext as n, TraceAnalystSpanKind as nt, AnalystInputKind as o, ViewTraceOversized as ot, AnalystUsageReceipt as p, DatasetOverview as q, AnalystCost as r, TraceAnalystSpanStatus as rt, AnalystRequirements as s, ViewTraceResult as st, Analyst as t, TraceAnalystSpan as tt, AnalystRunResult as u, ProposalFinding as v, FindingCalibration as w, makeFinding as x, ProposalFindingOrigin as y, BoundedTraceAnalysisStoreOptions as z };
+//# sourceMappingURL=types-CW8ewATZ.d.ts.map

package/dist/types-CW8ewATZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CW8ewATZ.d.ts","names":[],"sources":["../src/trace-analyst/types.ts","../src/trace-analyst/store-contract.ts","../src/trace-analyst/store-boundary.ts","../src/analyst/finding-scope.ts","../src/analyst/types.ts"],"mappings":";;;;;;;;;;;;KAsBY,uBAAuB;KAEvB;;;;UAKK;EACf;EACA;EACA;EACA;EACA,MAAM;EACN;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA;EACA;;;EAGA,YAAY;;UAGG;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA;;;;;;;UAQe;;EAEf;;EAEA;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;IAAU;IAAqB;;;;;;EAK/B,gBAAgB;EAChB;IAAc;IAAkB;;;UAGjB;EACf,QAAQ;EACR;EACA;;;;;UAMe;EACf;EACA,QAAQ;EACR,YAAY;;UAGG;EACf;;EAEA,gBAAgB;;EAEhB;EACA;;UAGe;EACf;EACA,OAAO;;EAEP;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,WAAW;;;EAGX;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA,MAAM;EACN;;UAGe;EACf;EACA;EACA,MAAM;EACN;;;UAIe;;;EAGf;;;EAGA;;;EAGA;;;EAGA;;cAGW,+BAA+B;;;cClM/B;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;UAGe;EACf,SAAS;;;UAIM;EACf;EACA;EACA;EACA;EACA;EACA;;KAGU;EAEN;EACA;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;IACA;IACA;;;;KAKI,oBACV,OAAO,qBACP,UAAU,8BACP,QAAQ;;;;;;;;UASI;;EAEf,iBAAiB;EAEjB,SAAS,kBAAkB,UAAU,4BAA4B;EAEjE,SACE;IAAS;IAAkB;KAC3B,UAAU,4BACT;EAEH,YACE,UAAU,qBACV,UAAU,4BACT,QAAQ;EAEX,YACE;IAAS,UAAU;IAAqB;IAAe;KACvD,UAAU,4BACT,QAAQ;EAEX,YAAY,UAAU,qBAAqB,UAAU,4BAA4B;EAEjF,UACE;IACE;IACA;KAEF,UAAU,4BACT,QAAQ;EAEX,UACE;IACE;IACA;IACA;KAEF,UAAU,4BACT,QAAQ;EAEX,YACE;IACE;IACA;IACA;KAEF,UAAU,4BACT,QAAQ;EAEX,WACE;IACE;IACA;IACA;IACA;KAEF,UAAU,4BACT,QAAQ;;UAGI;EACf,UAAU,QAAQ;;;;;iBC1GJ,gCACd,QAAQ,oBACR,UAAS,mCACR;;;;;;;;cCCU;KAaD,uBAAuB;UAOlB;;;;;;;;EAQf;;EAEA;;EAEA;IAAU;IAAc;;;EAExB;;UAGe;;EAEf;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,cAAc;;UAGC;EACf;EACA;EACA;EACA;;EAEA;;;;;;;;UASe;EACf;EACA,OAAO;EACP;;;cAuKW,uBAAqB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGN,EAAA,KAAA;KAQhB;EACN;EAAiB,OAAO;;EACxB;EAAkB;IAAS;IAAc;;;;iBAG/B,oBAAoB,iBAAiB;;;;;UAiBpC;EACf,OAAO;EACP;;EAEA;EACA;EACA,QAAQ;;;;;;;;KASE;iBAEI,iBAAiB,SAAS,iBAAiB;;;;;;iBAkC3C,aAAa,OAAO,cAAc,uBAAuB;;iBA0BzD,qBAAqB,OAAO,cAAc;;;;;;;;;;;;;UCvVzC;EACf,gBAAgB;;;;;;;EAOhB;EACA;EACA;EACA,UAAU;;;;;;;EAOV;EACA;EACA;EACA,eAAe;EACf;EACA;;EAEA;;;;;;EAMA;;;;EAIA;;EAEA,WAAW;;EAEX,QAAQ;;EAER,QAAQ;;EAER,SAAS;;EAET,UAAU;;EAEV;;EAEA;;;;;EAKA;;;;;EAKA,iBAAiB;;;cAIb;KAEM,sCAAsC;;;cAIrC;KAED,0BAA0B;;KAG1B;;KAGA,kBAAkB;WACnB,iBAAiB;;UAGX;;;;;;;EAOf;EACA;EACA;;;;;;;;KAWU;UAOK;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;;EAEA;;;;;;UAOe;EACf,aAAa;EACb;EACA,YAAY;EACZ,aAAa;;EAEb,SAAS;;UAGM;EACf;;EAEA;;EAEA;;EAEA;;EAEA,aAAa;;EAEb;;;;;;;EAOA,OAAO;;;;;;;;;;EAUP,gBAAgB,cAAc;;;;;;;EAO9B,mBAAmB,cAAc;;;;;EAKjC,eAAe,SAAS;;EAExB,OAAO;;EAEP,OAAO,aAAa,SAAS;;EAE7B,SAAS;;;;;;;;EAQT,QAAQ;;;UAMO;EACf;;EAEA;;EAEA;;EAEA;EACA,SAAS;;;;;;;KAQC;EAEN;EACA;EACA;EACA;EACA;;EAEA;;EAEA;EAAkB;IAAS;IAAe;;;;;;;;UAO/B;;WAEN;EACT,QAAQ,SAAS,wBAAwB,QAAQ;;;;;;;;UASlC,QAAQ;;WAEd;;WAEA;WACA,WAAW;WACX,MAAM;WACN,WAAW;;WAEX;EACT,QAAQ,OAAO,QAAQ,KAAK,iBAAiB,QAAQ;;;UAItC;;EAEf;;EAEA,QAAQ;;EAER,MAAM;;EAEN;;;;;;;;EAQA;IAAkB;IAAsB;;;;;;;;EAOxC;;;;;;;;;;iBAac,iBAAiB;EAC/B;EACA;EACA;EACA;;EAEA;;;;;;iBAqCc,YACd,MAAM,KAAK;EACT;EACA;IAED;;iBAmBa,oBACd,MAAM,KAAK;EACT;EACA;IAED;UAOc;EACf;EACA;;EAEA;EACA;EACA;;EAEA,OAAO;;EAEP;IAAU;IAAe;;;UAGV;EACf;EACA;EACA;EACA;EACA,UAAU;EACV,aAAa;;EAEb;;;;;EAKA,wBAAwB;;;;;;;;;;;;;;;KAkBd;EAEN;EACA;EACA;EACA;;EAEA,aAAa;;EAGb;EACA,SAAS;;EAGT;EACA;EACA;;EAGA;;EAEA,SAAS;EACT,UAAU,cAAc;;EAGxB;EACA,QAAQ"}

package/dist/{types-BqkVmHfv.d.ts → types-CmXY0PQf.d.ts}

@@ -98,8 +98,6 @@ interface SourceLimits {
   /** Reason no delivered artifact (patch/diff) is retained per worker (null = retained). */
   readonly deliverables: string | null;
 }
-/** A source that carries every fact the analyzer can use. */
-declare const NO_SOURCE_LIMITS: SourceLimits;
 /**
  * Everything the pure analyzer reads — already-read bytes, never paths. Each
  * field is `null` when its artifact was absent, which is what turns the
@@ -566,5 +564,5 @@ interface SupervisorRunTreeGap {
   readonly count?: number;
 }
 //#endregion
-export { WallDistribution as A, SupervisorRunSources as C, SupervisorStatusSource as D, SupervisorRunTreeGapCode as E, showMeasured as F, unavailable as I, WorkerNativeSession as M, WorkerTurnCoverage as N, TerminalFailure as O, isUnavailable as P, SupervisorRunRollup as S, SupervisorRunTreeGap as T, SpendMeasurements as _, NamedResourceReceipt as a, SupervisorRunReader as b, PatchStats as c, RoleSpend as d, RollupCellRow as f, SpendMeasurement as g, SourceLimits as h, NO_SOURCE_LIMITS as i, WorkerLogSource as j, Unavailable as k, PerWorkerRow as l, SUPERVISOR_RUN_SCHEMA as m, EconomicsMetrics as n, OrchestrationMetrics as o, SUPERVISOR_RUN_ROLLUP_SCHEMA as p, Measured as r, OutcomeMetrics as s, DecisionMetrics as t, ResourceSpendRecord as u, SteerBreakdown as v, SupervisorRunTree as w, SupervisorRunReport as x, SupervisorRunNodeRole as y };
-//# sourceMappingURL=types-BqkVmHfv.d.ts.map
+export { WorkerTurnCoverage as A, SupervisorRunTreeGapCode as C, WallDistribution as D, Unavailable as E, showMeasured as M, unavailable as N, WorkerLogSource as O, SupervisorRunTreeGap as S, TerminalFailure as T, SupervisorRunReader as _, OrchestrationMetrics as a, SupervisorRunSources as b, PerWorkerRow as c, RollupCellRow as d, SourceLimits as f, SupervisorRunNodeRole as g, SteerBreakdown as h, NamedResourceReceipt as i, isUnavailable as j, WorkerNativeSession as k, ResourceSpendRecord as l, SpendMeasurements as m, EconomicsMetrics as n, OutcomeMetrics as o, SpendMeasurement as p, Measured as r, PatchStats as s, DecisionMetrics as t, RoleSpend as u, SupervisorRunReport as v, SupervisorStatusSource as w, SupervisorRunTree as x, SupervisorRunRollup as y };
+//# sourceMappingURL=types-CmXY0PQf.d.ts.map

package/dist/types-CmXY0PQf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CmXY0PQf.d.ts","names":[],"sources":["../src/supervisor-run/types.ts"],"mappings":"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"}

package/dist/{types-C02qtnG8.d.ts → types-D-mgRzlh.d.ts}

@@ -110,12 +110,6 @@ interface AssertServedModelOptions {
   /** Prefixed to the thrown message, e.g. the judge or campaign cell name. */
   context?: string;
 }
-/**
- * The one place the accept/reject policy lives, so a caller that reports
- * substitution (a preflight table, a run record) and a caller that throws on it
- * can never drift apart. A cross-family substitution is never acceptable.
- */
-declare function servedModelAcceptable(check: ServedModelCheck, opts?: AssertServedModelOptions): boolean;
 /**
  * Throw `ModelSubstitutionError` unless the served id is the requested model.
  * Returns the check on success so callers can record the served id alongside
@@ -136,11 +130,6 @@ interface AssertCrossFamilyServedOptions extends AssertServedModelOptions {
   /** Count `unknown`-family served ids toward the total. Default false. */
   allowUnknown?: boolean;
 }
-declare class ServedCrossFamilyError extends AgentEvalError {
-  readonly families: JudgeFamily[];
-  readonly checks: ReadonlyArray<ServedModelCheck>;
-  constructor(message: string, families: JudgeFamily[], checks: ReadonlyArray<ServedModelCheck>);
-}
 /**
  * Family-diversity rule over the models that actually ANSWERED.
  *
@@ -231,11 +220,6 @@ interface RawProviderSink {
   close?(): Promise<void>;
 }
 type ProviderRedactor = (event: RawProviderEvent) => RawProviderEvent;
-/**
- * The default redactor: the redaction core over the parts of an event that
- * carry provider traffic. Every replaced path is added to `redactedFields`.
- */
-declare function defaultProviderRedactor(event: RawProviderEvent): RawProviderEvent;
 interface InMemoryRawProviderSinkOptions {
   redactor?: ProviderRedactor;
 }
@@ -280,11 +264,6 @@ declare class FileSystemRawProviderSink implements RawProviderSink {
   record(event: RawProviderEvent): Promise<void>;
   list(filter?: RawProviderSinkFilter): Promise<RawProviderEvent[]>;
 }
-/**
- * Best-effort provider id from a base URL. Falls back to the URL host when
- * none of the well-known patterns match.
- */
-declare function providerFromBaseUrl(baseUrl: string): string;
 //#endregion
 //#region src/llm-client/contract.d.ts
 interface LlmMessage {
@@ -630,7 +609,7 @@ interface MockTransportOpts extends BaseTransportOpts {
 declare function createChatClient(opts: CreateChatClientOpts): ChatClient;
 //#endregion
 //#region src/types.d.ts
-interface Scenario {
+interface ProductScenario {
   id: string;
   persona: string;
   label: string;
@@ -670,7 +649,7 @@ interface ScenarioResult {
   persona: string;
   turns: TurnResult[];
   artifactResults: ArtifactResult[];
-  judgeScores: JudgeScore[];
+  judgeScores: DimensionJudgeScore[];
   judgeErrors: number;
   overallScore: number;
   totalDurationMs: number;
@@ -695,7 +674,7 @@ interface ArtifactResult {
   passed: boolean;
   detail?: string;
 }
-interface JudgeScore {
+interface DimensionJudgeScore {
   judgeName: string;
   dimension: string;
   score: number;
@@ -809,7 +788,7 @@ interface DriverState {
   generations: number;
 }
 interface JudgeInput {
-  scenario: Scenario;
+  scenario: ProductScenario;
   turns: TurnResult[];
   artifacts: CollectedArtifacts;
   /** Shared ledger for paid built-in judges. Direct calls default to an uncapped ledger. */
@@ -818,7 +797,7 @@ interface JudgeInput {
   costTags?: Record<string, string>;
   signal?: AbortSignal;
 }
-type JudgeFn = (chat: ChatClient, input: JudgeInput) => Promise<JudgeScore[]>;
+type JudgeFn = (chat: ChatClient, input: JudgeInput) => Promise<DimensionJudgeScore[]>;
 interface CheckResult {
   name: string;
   passed: boolean;
@@ -826,5 +805,5 @@ interface CheckResult {
   actual: string;
 }
 //#endregion
-export { providerFromBaseUrl as $, createChatClient as A, LlmToolDefinition as B, ChatResponse as C, MockTransportOpts as D, CustomTransportOpts as E, LlmMessage as F, InMemoryRawProviderSinkOptions as G, FileSystemRawProviderSink as H, LlmThinkingMode as I, RawProviderDirection as J, NoopRawProviderSink as K, LlmTokenLogprob as L, LlmCallRequest as M, LlmCallResult as N, OpenAiCompatibleTransportOpts as O, LlmChargeBounds as P, defaultProviderRedactor as Q, LlmToolCall as R, ChatRequest as S, CreateChatClientOpts as T, FileSystemRawProviderSinkOptions as U, LlmUsage as V, InMemoryRawProviderSink as W, RawProviderSink as X, RawProviderEvent as Y, RawProviderSinkFilter as Z, ScenarioResult as _, CompletionCriterion as a, ServedModelPolicy as at, ChatCallOpts as b, JudgeInput as c, assertServedModel as ct, PersonaConfig as d, servedModelAcceptable as dt, AssertCrossFamilyServedOptions as et, ProductClientConfig as f, AssertCrossFamilyOptions as ft, ScenarioFile as g, judgeFamily as gt, Scenario as h, assertCrossFamily as ht, CollectedArtifacts as i, ServedModelCheck as it, LlmCallMetadata as j, SandboxSdkTransportOpts as k, JudgeRubric as l, assertServedModels as lt, RubricDimension as m, JudgeFamily as mt, ArtifactResult as n, ModelSubstitutionError as nt, DriverState as o, ServedModelVerdict as ot, RouteMap as p, CrossFamilyError as pt, ProviderRedactor as q, CheckResult as r, ServedCrossFamilyError as rt, JudgeFn as s, assertCrossFamilyServed as st, ArtifactCheck as t, AssertServedModelOptions as tt, JudgeScore as u, checkServedModel as ut, Turn as v, ChatTransport as w, ChatClient as x, TurnResult as y, LlmToolChoice as z };
-//# sourceMappingURL=types-C02qtnG8.d.ts.map
+export { AssertServedModelOptions as $, createChatClient as A, LlmToolDefinition as B, ChatResponse as C, MockTransportOpts as D, CustomTransportOpts as E, LlmMessage as F, InMemoryRawProviderSinkOptions as G, FileSystemRawProviderSink as H, LlmThinkingMode as I, RawProviderDirection as J, NoopRawProviderSink as K, LlmTokenLogprob as L, LlmCallRequest as M, LlmCallResult as N, OpenAiCompatibleTransportOpts as O, LlmChargeBounds as P, AssertCrossFamilyServedOptions as Q, LlmToolCall as R, ChatRequest as S, CreateChatClientOpts as T, FileSystemRawProviderSinkOptions as U, LlmUsage as V, InMemoryRawProviderSink as W, RawProviderSink as X, RawProviderEvent as Y, RawProviderSinkFilter as Z, ScenarioResult as _, CompletionCriterion as a, assertServedModel as at, ChatCallOpts as b, JudgeFn as c, AssertCrossFamilyOptions as ct, PersonaConfig as d, assertCrossFamily as dt, ModelSubstitutionError as et, ProductClientConfig as f, judgeFamily as ft, ScenarioFile as g, RubricDimension as h, CollectedArtifacts as i, assertCrossFamilyServed as it, LlmCallMetadata as j, SandboxSdkTransportOpts as k, JudgeInput as l, CrossFamilyError as lt, RouteMap as m, ArtifactResult as n, ServedModelPolicy as nt, DimensionJudgeScore as o, assertServedModels as ot, ProductScenario as p, ProviderRedactor as q, CheckResult as r, ServedModelVerdict as rt, DriverState as s, checkServedModel as st, ArtifactCheck as t, ServedModelCheck as tt, JudgeRubric as u, JudgeFamily as ut, Turn as v, ChatTransport as w, ChatClient as x, TurnResult as y, LlmToolChoice as z };
+//# sourceMappingURL=types-D-mgRzlh.d.ts.map

package/dist/types-D-mgRzlh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D-mgRzlh.d.ts","names":[],"sources":["../src/judge-families.ts","../src/integrity/served-model.ts","../src/trace/raw-provider-sink.ts","../src/llm-client/contract.ts","../src/analyst/chat-client.ts","../src/types.ts"],"mappings":"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AAuB;;;UChK7C;EACf;EACA;EACA;EACA;EACA;EACA,OAAO;EACP,gBAAgB;EAChB;;UAGe;EACf;EACA;EACA;EACA;;UAKe;EACf;EAQA;EACA;EACA;EACA;;UAKe;EACf;EACA;EACA,YAAY;;UAGG;EACf;EACA;EACA;EACA;EACA;;UAKe;EACf;EACA;EACA,OAAO;EACP,iBAAiB;EACjB,aAAa;EACb;EACA;EACA;EACA,WAAW;;EAEX,OAAO;;UAGQ;EACf;EACA;EACA;EACA;EACA;IAAmB;IAAc;;EACjC;EACA;;UAGe;EACf,OAAO;EACP;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;IAAc;IAAc;;EAC5B;IAAmB;IAAc,QAAQ;;EACzC;IAAc;IAAkB;;EAChC;;UAKe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;GACC;;UAGc;EACf;EACA,QAAQ;;EAER;;UAKe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;IACE;MACE;MACA;MACA;;;EAGJ,OAAO;EACP,gBAAgB;;UAKD;EACf;EACA,QAAQ,OAAO;EACf,YAAY,OAAO;;;;;;;;;;KAWhB;UAEY;EACf;EACA;EACA;EACA,oBAAoB;EACpB;;EAEA,QAAQ;;;;;;;EAOR;;;;;;;EAOA;;;;;;EAMA;;UAGe;EACf;EACA;EACA;IAAa;IAAiB;IAAkB;;EAChD;EACA;EACA;;UAGe;EACf,UAAU;EACV,OAAO;EACP,WAAW;;EAEX,aAAa;EACb;EACA,WAAW;EACX,SAAS;;KAGC,WAAW,MAAM,YAAY,OAAO,eAAe,QAAQ;UAMtD;EACf;EACA;EACA;EACA"}

package/dist/{types-Cq8mSbq8.d.ts → types-D8GhJoHk.d.ts}

@@ -1,11 +1,11 @@
 import { a as CostLedgerHandle, c as CostLedgerSummary, h as PaidCallResult, l as CostProvenance, r as CostChannel, v as RunPaidCallInput } from "./cost-ledger-Jk62OBfF.js";
-import { d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-C1E24G2A.js";
-import { b as ProposalFinding } from "./types-C1tnkEgM.js";
-import { j as LlmCallMetadata } from "./types-C02qtnG8.js";
+import { d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-CaxbLq6Y.js";
+import { v as ProposalFinding } from "./types-CW8ewATZ.js";
+import { j as LlmCallMetadata } from "./types-D-mgRzlh.js";
 import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
 import { A as SearchLedgerHash, G as SearchSplit, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, U as SearchReservation, Z as SearchTask, b as SearchClosedEvent, d as SearchCellCancelledEvent, i as SearchArtifactRef, l as SearchCandidateSurface, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, w as SearchEdgeRecordedEvent, z as SearchOperationRecordedEvent } from "./search-ledger-types-p2xKfiDJ.js";
-import { w as LedgerProjector } from "./index-DHKEAv3s.js";
-import { i as RolloutSearchLineage } from "./mint-DNU8QPG4.js";
+import { y as LedgerProjector } from "./index-9jJ2fKSX.js";
+import { i as RolloutSearchLineage } from "./mint-BRZXuwRi.js";
 //#region src/campaign/search-state-identity.d.ts
 /** Deterministic node id: identical content in one search is one node. */
 declare function searchNodeId(searchId: string, artifactDigest: string): string;
@@ -792,8 +792,6 @@ type RedactionStatus = 'raw' | 'redacted-pii' | 'redacted-secrets' | 'fully-reda
  *  explicitly assert trust to make a record gold-eligible — it never happens
  *  by accident). */
 type LabelTrust = 'unverified' | 'verified-signal' | 'human-rated';
-/** Ordinal rank for a label-trust tier; absent ⇒ `unverified` (rank 0). */
-declare function labelTrustRank(trust: LabelTrust | undefined): number;
 /** Required-provenance write. The store rejects writes that
  *  lack provenance — a default-on flywheel without provenance is the
  *  data-poisoning vector flagged in the alignment review. */
@@ -1020,5 +1018,5 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
   scenarios: Array<CampaignScenarioIdentity & Pick<TScenario, 'id' | 'kind'>>;
 }
 //#endregion
-export { SearchCell as $, LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, labelTrustRank as G, SurfaceProposer as H, ProposedCandidate as I, renderSearchSummary as J, SearchProposerView as K, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, searchUnitScores as Q, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, SearchState as X, searchProposerView as Y, SearchStateView as Z, GateDecision as _, CampaignResult as a, SearchSpend as at, GenerationRecord as b, CampaignTraceWriter as c, searchNodeId as ct, DispatchContext as d, SearchCompletion as et, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchScoredCell as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, searchTaskSetDigest as lt, GateCheckStatus as m, CampaignArtifactWriter as n, SearchNode as nt, CampaignScenarioIdentity as o, SearchUnitScore as ot, Gate as p, SearchSummaryOptions as q, CampaignCellResult as r, SearchOperation as rt, CampaignTokenUsage as s, searchCellId as st, CampaignAggregates as t, SearchDecisionRecord as tt, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
-//# sourceMappingURL=types-Cq8mSbq8.d.ts.map
+export { SearchCompletion as $, LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, SearchProposerView as G, SurfaceProposer as H, ProposedCandidate as I, searchProposerView as J, SearchSummaryOptions as K, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, SearchCell as Q, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, SearchStateView as X, SearchState as Y, searchUnitScores as Z, GateDecision as _, CampaignResult as a, SearchUnitScore as at, GenerationRecord as b, CampaignTraceWriter as c, searchTaskSetDigest as ct, DispatchContext as d, SearchDecisionRecord as et, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchSpend as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, GateCheckStatus as m, CampaignArtifactWriter as n, SearchOperation as nt, CampaignScenarioIdentity as o, searchCellId as ot, Gate as p, renderSearchSummary as q, CampaignCellResult as r, SearchScoredCell as rt, CampaignTokenUsage as s, searchNodeId as st, CampaignAggregates as t, SearchNode as tt, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
+//# sourceMappingURL=types-D8GhJoHk.d.ts.map

package/dist/{types-Cq8mSbq8.d.ts.map → types-D8GhJoHk.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-Cq8mSbq8.d.ts","names":[],"sources":["../src/campaign/search-state-identity.ts","../src/campaign/search-state-types.ts","../src/campaign/search-state-view.ts","../src/campaign/search-state-projection.ts","../src/campaign/search-summary.ts","../src/campaign/types.ts"],"mappings":"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"}
+{"version":3,"file":"types-D8GhJoHk.d.ts","names":[],"sources":["../src/campaign/search-state-identity.ts","../src/campaign/search-state-types.ts","../src/campaign/search-state-view.ts","../src/campaign/search-state-projection.ts","../src/campaign/search-summary.ts","../src/campaign/types.ts"],"mappings":"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"}

package/dist/{types-IXD2HJzu.js → types-DqFMNTgK.js}

@@ -16,8 +16,6 @@ import { createHash } from "node:crypto";
 * a RunRecord, a JudgeInput, or `custom`), and the registry routes
 * the matching input from `AnalystRunInputs`.
 */
-/** Every finding schema this package reads. Writers emit 1.1.0 only when a 1.1.0 field is set. */
-const ANALYST_FINDING_SCHEMA_VERSIONS = ["1.0.0", "1.1.0"];
 /** Finding severity. `AnalystSeverity` derives from this array, so the type
 *  and the schema that validates a finding cannot name different levels. */
 const ANALYST_SEVERITIES = [
@@ -86,6 +84,6 @@ function makeProposalFinding(init) {
 	};
 }
 //#endregion
-export { makeFinding as a, computeFindingId as i, ANALYST_SEVERITIES as n, makeProposalFinding as o, FINDING_SCOPE_FIELDS as r, ANALYST_FINDING_SCHEMA_VERSIONS as t };
+export { makeProposalFinding as a, makeFinding as i, FINDING_SCOPE_FIELDS as n, computeFindingId as r, ANALYST_SEVERITIES as t };
 
-//# sourceMappingURL=types-IXD2HJzu.js.map
+//# sourceMappingURL=types-DqFMNTgK.js.map

package/dist/types-DqFMNTgK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DqFMNTgK.js","names":[],"sources":["../src/analyst/types.ts"],"sourcesContent":["/**\n * Analyst contract — the missing orchestration layer over agent-eval's\n * existing analyzers (analyzeTraces, MultiLayerVerifier,\n * SemanticConceptJudge, JudgeFn, ...).\n *\n * Each existing primitive returns its own output shape. The Analyst\n * contract is the single envelope every primitive lifts into, so a\n * registry can run N analysts against a run and a single renderer can\n * compose findings without knowing which analyzer produced them.\n *\n * The contract is intentionally domain-agnostic: nothing here knows\n * about code, voice, RAG, or any particular agent stack. Analysts\n * declare what INPUT KIND they need (a trace store, an artifact dir,\n * a RunRecord, a JudgeInput, or `custom`), and the registry routes\n * the matching input from `AnalystRunInputs`.\n */\n\nimport { createHash } from 'node:crypto'\nimport type { CostLedgerHandle, CostProvenance } from '../cost-ledger'\nimport type { RunRecord, RunTokenUsage } from '../run-record'\nimport type { TraceAnalysisStore } from '../trace-analyst/store'\nimport type { JudgeInput } from '../types'\nimport type { ChatClient } from './chat-client'\nimport type {\n  FindingEvidenceUnit,\n  FindingLayer,\n  FindingMeasure,\n  FindingMethod,\n  FindingScope,\n} from './finding-scope'\n\n/**\n * Unified envelope every analyst emits. Schema-versioned so renderers\n * and time-series diffs survive future field additions.\n *\n * 1.1.0 adds what a finding is about and what it was measured on: `layer`,\n * `scope`, `method`, `measure`, `confounders`, `valid_for`, `claim_id` and\n * `evidence_units`. They are all optional, and a 1.0.0 finding carries none of\n * them; `readFindingScope` reads such a finding as layer and n unknown.\n * `parseAnalystFinding` (finding-scope.ts) is the one validator for both.\n */\nexport interface AnalystFinding {\n  schema_version: AnalystFindingSchemaVersion\n  /**\n   * Stable hash over identity-defining fields (analyst_id + canonical\n   * claim + area + optional subject). Two findings from two runs that\n   * \"are the same finding\" share this id — that's what `diffFindings`\n   * uses to compute appeared/disappeared sets across runs.\n   */\n  finding_id: string\n  analyst_id: string\n  produced_at: string\n  severity: AnalystSeverity\n  /**\n   * Coarse classification. Renderers group by this. Free-form so\n   * domain-specific analysts can introduce categories without a\n   * schema change ('agent-reasoning', 'verification', 'cost',\n   * 'tool-use', 'safety', 'latency', 'data-quality', ...).\n   */\n  area: string\n  claim: string\n  rationale?: string\n  evidence_refs: EvidenceRef[]\n  recommended_action?: string\n  validation_plan?: string\n  /** 0..1 — the analyst's own confidence. Not calibrated across analysts. */\n  confidence: number\n  /**\n   * Optional subject the finding is about — leaf id, agent id, request\n   * id. Included in finding_id when present so per-subject findings\n   * diff cleanly across runs.\n   */\n  subject?: string\n  /** True when this finding was lifted from a judge result rather than observed\n   *  directly in a trace or artifact. Descriptive only: proposal access is\n   *  controlled by `ProposalFinding.proposal_origin`. */\n  derived_from_judge?: boolean\n  /** Analyst-private extras; renderers ignore unless they know the analyst. */\n  metadata?: Record<string, unknown>\n  /** 1.1.0: the level the claim is about, from one event up to the whole lab. */\n  layer?: FindingLayer\n  /** 1.1.0: the population the claim was measured on. */\n  scope?: FindingScope\n  /** 1.1.0: how the claim was produced, and the judge's calibration when judged. */\n  method?: FindingMethod\n  /** 1.1.0: the number behind the claim, when it has one. */\n  measure?: FindingMeasure\n  /** 1.1.0: known differences between the compared units besides the treatment. */\n  confounders?: string[]\n  /** 1.1.0: the conditions the claim was measured under, in words. */\n  valid_for?: string\n  /**\n   * 1.1.0: stable key for the claim across subjects and layers. `promote`\n   * groups children by it; a finding without one never lifts.\n   */\n  claim_id?: string\n  /**\n   * 1.1.0: the measured units with their lineage. When present, `scope.n` and\n   * `scope.population` must match them and no unit may sit above `layer`.\n   */\n  evidence_units?: FindingEvidenceUnit[]\n}\n\n/** Every finding schema this package reads. Writers emit 1.1.0 only when a 1.1.0 field is set. */\nconst ANALYST_FINDING_SCHEMA_VERSIONS = ['1.0.0', '1.1.0'] as const\n\nexport type AnalystFindingSchemaVersion = (typeof ANALYST_FINDING_SCHEMA_VERSIONS)[number]\n\n/** Finding severity. `AnalystSeverity` derives from this array, so the type\n *  and the schema that validates a finding cannot name different levels. */\nexport const ANALYST_SEVERITIES = ['critical', 'high', 'medium', 'low', 'info'] as const\n\nexport type AnalystSeverity = (typeof ANALYST_SEVERITIES)[number]\n\n/** Data sources that candidate generation may intentionally learn from. */\nexport type ProposalFindingOrigin = 'search' | 'production'\n\n/** A finding explicitly admitted as candidate-generation input. */\nexport type ProposalFinding = AnalystFinding & {\n  readonly proposal_origin: ProposalFindingOrigin\n}\n\nexport interface EvidenceRef {\n  /**\n   * Where the evidence lives. `span` and `event` refer to OTLP trace\n   * elements; `artifact` to a file inside the run's artifact tree;\n   * `finding` to another AnalystFinding (cross-analyst chaining);\n   * `metric` to a named scalar reading the renderer knows how to read.\n   */\n  kind: 'span' | 'event' | 'artifact' | 'finding' | 'metric'\n  uri: string\n  excerpt?: string\n}\n\n// ── Analyst contract ─────────────────────────────────────────────────\n\n/**\n * The discriminator the registry uses to pass the right input.\n * `custom` is the escape hatch — analysts that need something else\n * (e.g. an embedding cache, a partner SDK handle) read it from\n * `AnalystRunInputs.custom[<analyst id>]`.\n */\nexport type AnalystInputKind =\n  | 'trace-store'\n  | 'artifact-dir'\n  | 'run-record'\n  | 'judge-input'\n  | 'custom'\n\nexport interface AnalystCost {\n  /** `deterministic` analysts MUST NOT call the LLM. */\n  kind: 'deterministic' | 'llm'\n  /** Optional declared upper bound; the registry can enforce a budget. */\n  est_usd_per_run?: number\n  /** Models the analyst expects to use (informational). */\n  models?: string[]\n  /** Maximum post-cancellation wait for provider usage. Model analysts default to 5 seconds. */\n  settlement_timeout_ms?: number\n}\n\nexport interface AnalystRequirements {\n  /** Min number of shots / samples the analyst needs to produce signal. */\n  min_shots?: number\n  /** Capabilities the runtime must supply (e.g. ['network', 'gpu']). */\n  capabilities?: string[]\n}\n\n/**\n * What's passed to every analyst call. The registry resolves which\n * field the analyst's `inputKind` selects and asserts it's present.\n */\nexport interface AnalystRunInputs {\n  traceStore?: TraceAnalysisStore\n  artifactDir?: string\n  runRecord?: RunRecord\n  judgeInput?: JudgeInput\n  /** Keyed by analyst id; populated by callers that registered custom analysts. */\n  custom?: Record<string, unknown>\n}\n\nexport interface AnalystContext {\n  runId: string\n  /** Stable correlation id so logs from a single registry.run() share a tag. */\n  correlationId: string\n  /** Enforced wall-clock deadline (epoch ms). */\n  deadlineMs?: number\n  /** Per-analyst USD budget. Analysts MAY check before issuing LLM calls. */\n  budgetUsd?: number\n  /** Shared paid-call account when the analyst runs inside a larger campaign. */\n  costLedger?: CostLedgerHandle\n  /** Attribution phase used when writing to the shared paid-call account. */\n  costPhase?: string\n  /**\n   * Shared chat client. Analysts that call an LLM go through this so\n   * the operator picks transport (sandbox-sdk | router | cli-bridge |\n   * direct-provider | mock) at the registry boundary without touching\n   * analyst code.\n   */\n  chat?: ChatClient\n  /**\n   * Findings from a prior run the operator wants the analyst to see as\n   * retrieval context. Kinds that take advantage of cross-run memory\n   * (failure-mode \"I saw this cluster last run\", knowledge-gap \"the wiki\n   * page I asked for is still missing\") render these into the actor's\n   * working set. Filtering is the operator's job: pass the slice that\n   * matches the analyst's id, or pass everything and let the kind\n   * filter. Empty / absent means no cross-run context.\n   */\n  priorFindings?: ReadonlyArray<AnalystFinding>\n  /**\n   * Findings emitted by analysts that completed earlier in this registry run.\n   * This is separate from `priorFindings`: upstream findings are dependency\n   * context for the current pass, while prior findings are cross-run memory.\n   * The registry populates this only when `RegistryRunOpts.chainFindings` is on.\n   */\n  upstreamFindings?: ReadonlyArray<AnalystFinding>\n  /**\n   * Report metered work independently of findings. This keeps an empty finding\n   * set from erasing token/cost telemetry. Multiple receipts are accumulated.\n   */\n  recordUsage?: (receipt: AnalystUsageReceipt) => void\n  /** Free-form runtime tags (env, host, op). Findings can echo these into metadata. */\n  tags?: Record<string, string>\n  /** Logger callback — analysts SHOULD prefer this over console.* for testability. */\n  log?: (msg: string, fields?: Record<string, unknown>) => void\n  /** Optional abort signal. Analysts SHOULD pass it through to LLM calls. */\n  signal?: AbortSignal\n  /**\n   * Optional live-execution port. A runtime that owns a sandbox or checkout\n   * fills it so an analyst can execute a bounded probe against the run's\n   * produced state instead of reasoning about it from the trace alone. This\n   * package defines only the port: no field here reaches for an agent loop,\n   * and an absent probe means the analyst works from recorded evidence.\n   */\n  probe?: ExecutionProbe\n}\n\n// ── Live-execution port ─────────────────────────────────────────────\n\n/** One bounded command an analyst asks the probe to run. */\nexport interface ExecutionProbeRequest {\n  command: string\n  /** Working directory inside the probed environment. */\n  cwd?: string\n  /** Hard wall-clock deadline for this one execution. */\n  timeoutMs: number\n  /** Bytes of combined output retained; the prober truncates beyond it. */\n  maxOutputBytes?: number\n  signal?: AbortSignal\n}\n\n/**\n * Typed outcome of one probe execution. `succeeded: false` is a PROBE failure\n * (the environment could not run the command); a command that ran and exited\n * non-zero is a successful observation with a non-zero `exitCode`.\n */\nexport type ExecutionProbeOutcome =\n  | {\n      succeeded: true\n      exitCode: number\n      stdout: string\n      stderr: string\n      durationMs: number\n      /** True when output was cut at `maxOutputBytes`. */\n      truncated: boolean\n    }\n  | { succeeded: false; error: { class: string; message: string } }\n\n/**\n * The seam a runtime fills to let analysts observe produced state live.\n * Implementations own sandboxing, credentials, and cleanup; analysts only\n * submit bounded requests and read typed outcomes.\n */\nexport interface ExecutionProbe {\n  /** One plain sentence naming what is being probed (e.g. a sandbox id). */\n  readonly description: string\n  execute(request: ExecutionProbeRequest): Promise<ExecutionProbeOutcome>\n}\n\n/**\n * The minimal contract. Concrete analysts can refine `TInput` so\n * implementations stay type-safe (e.g. a trace analyst's `TInput` is\n * `TraceAnalysisStore`); the registry passes the right field from\n * `AnalystRunInputs` based on `inputKind`.\n */\nexport interface Analyst<TInput = unknown> {\n  /** Stable identifier — appears in finding_id, telemetry, and registry exclusion lists. */\n  readonly id: string\n  /** Human-readable. One sentence. */\n  readonly description: string\n  readonly inputKind: AnalystInputKind\n  readonly cost: AnalystCost\n  readonly requires?: AnalystRequirements\n  /** Bump on breaking changes to claim wording or area so old finding_ids don't collide. */\n  readonly version: string\n  analyze(input: TInput, ctx: AnalystContext): Promise<AnalystFinding[]>\n}\n\n/** Metered work performed by one analyst call. */\nexport interface AnalystUsageReceipt {\n  /** Number of model-usage records observed at the provider boundary. */\n  calls: number | null\n  /** Null when the provider did not return token accounting. */\n  tokens: RunTokenUsage | null\n  /** Observed, estimated, or explicitly uncaptured dollar cost. */\n  cost: CostProvenance\n  /** Known lower bound when one or more calls have uncaptured cost. */\n  knownCostUsd?: number\n  /**\n   * Token counts the provider reported on only one side. Present exactly when\n   * `tokens` is null and at least one side WAS reported: `RunTokenUsage` has no\n   * nullable side, so a one-sided count cannot live in `tokens` without writing\n   * a zero nobody measured. Read it as a lower bound, never as a total — the\n   * field exists so a null `tokens` cannot hide a real count.\n   */\n  partialTokens?: { input: number | null; output: number | null }\n  /**\n   * True when the token counts were DERIVED by the transport (from character\n   * lengths, say) rather than measured by the model provider. `cost.kind` is\n   * `estimated` both for a rate estimate over exact tokens and for one over\n   * derived tokens; this is the field that separates them.\n   */\n  tokensEstimated?: boolean\n}\n\n// ── finding_id stability ─────────────────────────────────────────────\n\n/**\n * Compute the stable finding_id from the identity-defining fields.\n * Default implementation hashes {analyst_id, area, subject, normalized claim}.\n * Analysts that emit findings whose claim text varies per run (timestamps,\n * counts) SHOULD either: (a) pass an explicit `id_basis` to fix the hash,\n * or (b) move the variable part into `rationale`/`metadata` and keep the\n * `claim` static.\n */\nexport function computeFindingId(input: {\n  analyst_id: string\n  area: string\n  subject?: string\n  claim: string\n  /** Override the claim for hashing — use when the displayed claim has run-specific bits. */\n  id_basis?: string\n}): string {\n  const basis = JSON.stringify({\n    a: input.analyst_id,\n    r: input.area,\n    s: input.subject ?? '',\n    c: normalizeClaim(input.id_basis ?? input.claim),\n  })\n  return `f_${createHash('sha256').update(basis).digest('hex').slice(0, 20)}`\n}\n\nfunction normalizeClaim(c: string): string {\n  // Lowercase, collapse whitespace, strip trailing punctuation. Goal:\n  // \"Leaf X failed install\" and \"Leaf X failed install.\" hash the same.\n  return c\n    .toLowerCase()\n    .replace(/\\s+/g, ' ')\n    .replace(/[.!?;:,]+$/g, '')\n    .trim()\n}\n\n/** Fields that exist only in schema 1.1.0. */\nexport const FINDING_SCOPE_FIELDS = [\n  'layer',\n  'scope',\n  'method',\n  'measure',\n  'confounders',\n  'valid_for',\n  'claim_id',\n  'evidence_units',\n] as const satisfies ReadonlyArray<keyof AnalystFinding>\n\n/**\n * Convenience factory: produce a fully-formed AnalystFinding with the\n * id computed automatically. Analyst code stays terse.\n */\nexport function makeFinding(\n  init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {\n    id_basis?: string\n    produced_at?: string\n  },\n): AnalystFinding {\n  const { id_basis, produced_at, ...rest } = init\n  return {\n    schema_version: FINDING_SCOPE_FIELDS.some((field) => rest[field] !== undefined)\n      ? '1.1.0'\n      : '1.0.0',\n    finding_id: computeFindingId({\n      analyst_id: rest.analyst_id,\n      area: rest.area,\n      subject: rest.subject,\n      claim: rest.claim,\n      id_basis,\n    }),\n    produced_at: produced_at ?? new Date().toISOString(),\n    ...rest,\n  }\n}\n\n/** Build a finding whose source is explicitly allowed during candidate generation. */\nexport function makeProposalFinding(\n  init: Omit<ProposalFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {\n    id_basis?: string\n    produced_at?: string\n  },\n): ProposalFinding {\n  const { proposal_origin, ...finding } = init\n  return { ...makeFinding(finding), proposal_origin }\n}\n\n// ── Registry result envelope ────────────────────────────────────────\n\nexport interface AnalystRunSummary {\n  analyst_id: string\n  status: 'ok' | 'skipped' | 'failed'\n  /** Why skipped — missing input, budget exceeded, capability unmet. */\n  reason?: string\n  findings_count: number\n  latency_ms: number\n  /** Additive model usage and cost provenance for this analyst. */\n  usage: AnalystUsageReceipt\n  /** When `status='failed'`: the error class + message, never the full stack. */\n  error?: { class: string; message: string }\n}\n\nexport interface AnalystRunResult {\n  run_id: string\n  correlation_id: string\n  started_at: string\n  ended_at: string\n  findings: AnalystFinding[]\n  per_analyst: AnalystRunSummary[]\n  /** Total LLM cost in USD across all analysts in this registry.run(). */\n  total_cost_usd: number\n  /**\n   * Provenance for `total_cost_usd`. When uncaptured, the numeric field is only\n   * the known subtotal and must not be treated as the run's total spend.\n   */\n  total_cost_provenance?: CostProvenance\n}\n\n// ── Streaming event envelope ────────────────────────────────────────\n\n/**\n * Events emitted by `AnalystRegistry.runStream(...)` in real time as\n * the registry executes. UIs subscribe via `for await (const ev of\n * registry.runStream(...))`; `registry.run(...)` is a thin collector\n * over the same stream, so the two surfaces share their invariants.\n *\n * Per-finding events are intentionally omitted — analyzers are batch\n * operations (a recursive engine returns the full `findings:json[]` at the\n * end of the responder), so streaming inside one analyst would only\n * emit partial JSON consumers can't render. The kind-completion event\n * is the right granularity; subscribers wanting per-finding rendering\n * iterate `event.findings` themselves.\n */\nexport type AnalystRunEvent =\n  | {\n      type: 'run-started'\n      run_id: string\n      correlation_id: string\n      started_at: string\n      /** The ordered list of analyst ids the registry will run. */\n      analyst_ids: ReadonlyArray<string>\n    }\n  | {\n      type: 'analyst-skipped'\n      summary: AnalystRunSummary\n    }\n  | {\n      type: 'analyst-started'\n      analyst_id: string\n      started_at: string\n    }\n  | {\n      type: 'analyst-completed'\n      /** `summary.status` is `'ok'` for clean completion or `'failed'` for thrown analysts. */\n      summary: AnalystRunSummary\n      findings: ReadonlyArray<AnalystFinding>\n    }\n  | {\n      type: 'run-completed'\n      result: AnalystRunResult\n    }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA8GA,MAAa,qBAAqB;CAAC;CAAY;CAAQ;CAAU;CAAO;AAAM;;;;;;;;;AAiO9E,SAAgB,iBAAiB,OAOtB;CACT,MAAM,QAAQ,KAAK,UAAU;EAC3B,GAAG,MAAM;EACT,GAAG,MAAM;EACT,GAAG,MAAM,WAAW;EACpB,GAAG,eAAe,MAAM,YAAY,MAAM,KAAK;CACjD,CAAC;CACD,OAAO,KAAK,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;AAC1E;AAEA,SAAS,eAAe,GAAmB;CAGzC,OAAO,EACJ,YAAY,CAAC,CACb,QAAQ,QAAQ,GAAG,CAAC,CACpB,QAAQ,eAAe,EAAE,CAAC,CAC1B,KAAK;AACV;;AAGA,MAAa,uBAAuB;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;AAMA,SAAgB,YACd,MAIgB;CAChB,MAAM,EAAE,UAAU,aAAa,GAAG,SAAS;CAC3C,OAAO;EACL,gBAAgB,qBAAqB,MAAM,UAAU,KAAK,WAAW,KAAA,CAAS,IAC1E,UACA;EACJ,YAAY,iBAAiB;GAC3B,YAAY,KAAK;GACjB,MAAM,KAAK;GACX,SAAS,KAAK;GACd,OAAO,KAAK;GACZ;EACF,CAAC;EACD,aAAa,gCAAe,IAAI,KAAK,EAAA,CAAE,YAAY;EACnD,GAAG;CACL;AACF;;AAGA,SAAgB,oBACd,MAIiB;CACjB,MAAM,EAAE,iBAAiB,GAAG,YAAY;CACxC,OAAO;EAAE,GAAG,YAAY,OAAO;EAAG;CAAgB;AACpD"}

package/dist/{types-Cbe2fWBa.d.ts → types-DtMbFw6U.d.ts}

@@ -1,5 +1,5 @@
-import { c as RunSplitTag } from "./run-record-C1E24G2A.js";
-import { R as Scenario, d as DispatchContext } from "./types-Cq8mSbq8.js";
+import { c as RunSplitTag } from "./run-record-CaxbLq6Y.js";
+import { R as Scenario, d as DispatchContext } from "./types-D8GhJoHk.js";
 //#region src/benchmarks/types.d.ts
 type BenchmarkTaskKind = 'retrieval' | 'rag-answer' | 'hallucination' | 'kb-improvement' | 'routing' | 'custom';
 type BenchmarkFamily = 'beir' | 'mteb-retrieval' | 'msmarco' | 'trec-dl' | 'miracl' | 'lotte' | 'bright' | 'crag' | 'hotpotqa' | 'kilt' | 'ragtruth' | 'faithbench' | 'first-party' | 'custom';
@@ -99,4 +99,4 @@ declare const BENCHMARK_SPLIT_SEED = "agent-eval-v1";
 declare function deterministicSplit(itemId: string, seed?: string): RunSplitTag;
 //#endregion
 export { BenchmarkFamily as a, BenchmarkSource as c, BenchmarkEvaluation as i, BenchmarkTaskKind as l, BenchmarkAdapter as n, BenchmarkResponder as o, BenchmarkDatasetItem as r, BenchmarkScenario as s, BENCHMARK_SPLIT_SEED as t, deterministicSplit as u };
-//# sourceMappingURL=types-Cbe2fWBa.d.ts.map
+//# sourceMappingURL=types-DtMbFw6U.d.ts.map

package/dist/{types-Cbe2fWBa.d.ts.map → types-DtMbFw6U.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-Cbe2fWBa.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;;;;EAKA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}
+{"version":3,"file":"types-DtMbFw6U.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;;;;EAKA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}

package/dist/{verdict-Dl0tiT1X.js → verdict-BGQmxQ8A.js}

@@ -1,4 +1,4 @@
-import { n as contentHash } from "./verdict-cache-Bm8EKL2s.js";
+import { n as contentHash } from "./verdict-cache-CL_7tePD.js";
 //#region src/verdict.ts
 /**
 * Validator-output verdict — substrate primitive for "did this output pass,
@@ -13,7 +13,7 @@ import { n as contentHash } from "./verdict-cache-Bm8EKL2s.js";
 *
 * Repo layering: agent-eval is the substrate (no upward deps). Both
 * agent-runtime and agent-knowledge consume this type FROM agent-eval —
-* never the other way around. See CLAUDE.md "Repo layering" for the rule.
+* never the other way around. See AGENTS.md "Dependency and evidence boundaries" for the rule.
 */
 /**
 * Digest a certification's evidence artifact: sha-256 over the canonical
@@ -58,4 +58,4 @@ function equivalenceVerdict(record) {
 //#endregion
 export { equivalenceVerdict as n, certificationEvidenceDigest as t };
 
-//# sourceMappingURL=verdict-Dl0tiT1X.js.map
+//# sourceMappingURL=verdict-BGQmxQ8A.js.map

package/dist/verdict-BGQmxQ8A.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict-BGQmxQ8A.js","names":[],"sources":["../src/verdict.ts"],"sourcesContent":["/**\n * Validator-output verdict — substrate primitive for \"did this output pass,\n * and how well?\"\n *\n * Used by:\n *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.\n *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.\n *     Runtime keeps `Validator` because it's coupled to runtime-shaped\n *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE\n *     itself is a substrate concept and lives here.\n *\n * Repo layering: agent-eval is the substrate (no upward deps). Both\n * agent-runtime and agent-knowledge consume this type FROM agent-eval —\n * never the other way around. See AGENTS.md \"Dependency and evidence boundaries\" for the rule.\n */\n\nimport { contentHash } from './verdict-cache'\nimport type {\n  CheckerIdentity,\n  EquivalenceRecord,\n  VerificationStrategySource,\n} from './verification-strategy'\n\n/**\n * What certified a verdict — the epistemics a bare `valid` + `score` pair\n * cannot carry. A kernel-checked proof and an LLM judge can produce the\n * same `{ valid: true, score: 1 }`; this record is what tells them apart.\n *\n * Every field is required on purpose. A certification without a checker\n * identity or an evidence digest is exactly the unverifiable claim this\n * record exists to kill.\n */\nexport interface VerdictCertification {\n  /**\n   * Which verification-strategy member produced the certificate. Each\n   * member's failure mode is documented on the family type and in\n   * `VERIFICATION_STRATEGIES` (src/verification-strategy.ts).\n   */\n  strategy: VerificationStrategySource\n  /**\n   * Exact checker identity, e.g. `{ name: 'lean4', version: '4.33.0',\n   * pins: { mathlib: 'db584cd6d46c' } }` for a kernel, or a judge model\n   * id + snapshot for a judge.\n   */\n  checker: CheckerIdentity\n  /**\n   * Every step the certificate rests on that the checker did NOT verify,\n   * e.g. 'diagonal embedding argued in prose' or 'agreement arms share\n   * training-corpus blind spots'. An empty array is the producer's\n   * explicit, auditable claim that there are none — it is not a default.\n   */\n  assumptions: string[]\n  /** Digest (e.g. sha256) of the evidence artifact the checker consumed or produced. */\n  evidenceDigest: string\n}\n\n/**\n * Minimal verdict shape — `valid` + `score` are required; `scores` +\n * `notes` are optional surface. Validators that need richer shapes\n * parameterise `Validator<Output, MyVerdict>` with their own type.\n *\n * Need structured extras? Extend DefaultVerdict with typed fields — never\n * serialize extras into `notes`.\n */\nexport interface DefaultVerdict {\n  /** Whether the output meets the validator's pass criteria. */\n  valid: boolean\n  /** Aggregate score in [0, 1]. Drivers use this for winner selection. */\n  score: number\n  /** Per-dimension scores. Free-form; weighted into `score` by the validator. */\n  scores?: Record<string, number>\n  /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */\n  notes?: string\n  /**\n   * What certified this verdict, when anything did. Absent = uncertified:\n   * scored, but no strategy vouches for it. A consumer that cares reads\n   * `certification.strategy` to tell a kernel-checked verdict from a\n   * judge-scored one; a consumer that does not read it sees the exact\n   * verdict it always saw.\n   */\n  certification?: VerdictCertification\n}\n\n/**\n * Digest a certification's evidence artifact: sha-256 over the canonical\n * JSON of the evidence AS SERIALIZED. The JSON round-trip drops\n * `undefined`-valued fields on purpose — certified verdicts persist as\n * JSON, so the digest must cover exactly what a reader of the persisted\n * artifact can re-digest, nothing the wire cannot carry. Throws when the\n * evidence has no JSON form at all.\n */\nexport function certificationEvidenceDigest(evidence: unknown): string {\n  const serialized = JSON.stringify(evidence)\n  if (serialized === undefined) {\n    throw new Error(\n      'certificationEvidenceDigest: evidence has no JSON form — a certificate over nothing is the unverifiable claim this record exists to kill',\n    )\n  }\n  return contentHash(JSON.parse(serialized))\n}\n\n/**\n * Land a finished statement-equivalence record in the shared verdict\n * spine. `valid` answers the protocol's question — are the two blind\n * statements equivalent — so a refutation is `valid: false` even though a\n * separating witness in hand is a successful protocol outcome.\n *\n * Certification is present exactly when the obligation was discharged\n * (proved or refuted): the checker vouches for the discharge either way.\n * An unresolved obligation certifies nothing and keeps its reason in\n * `notes`.\n */\nexport function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict {\n  const { obligation, spec, arms } = record\n  const discharged = obligation.status !== 'unresolved'\n  const notes =\n    obligation.status === 'proved'\n      ? `statements equivalent: ${spec.artifact}`\n      : obligation.status === 'refuted-with-separating-witness'\n        ? `formalization gap witnessed: ${obligation.separatingWitness}`\n        : `obligation undischarged: ${obligation.unresolvedReason}`\n  return {\n    valid: obligation.status === 'proved',\n    score: obligation.status === 'proved' ? 1 : 0,\n    notes,\n    ...(discharged && obligation.evidenceDigest !== undefined\n      ? {\n          certification: {\n            strategy: spec.source,\n            checker: obligation.checker,\n            // The arms' blindness declarations are attested by the arms,\n            // never verified by the checker — the one step every\n            // equivalence certificate rests on.\n            assumptions: [\n              `arm '${arms[0].armId}' and arm '${arms[1].armId}' self-declare blind derivation`,\n            ],\n            evidenceDigest: obligation.evidenceDigest,\n          } satisfies VerdictCertification,\n        }\n      : {}),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,4BAA4B,UAA2B;CACrE,MAAM,aAAa,KAAK,UAAU,QAAQ;CAC1C,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,0IACF;CAEF,OAAO,YAAY,KAAK,MAAM,UAAU,CAAC;AAC3C;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,QAA2C;CAC5E,MAAM,EAAE,YAAY,MAAM,SAAS;CACnC,MAAM,aAAa,WAAW,WAAW;CACzC,MAAM,QACJ,WAAW,WAAW,WAClB,0BAA0B,KAAK,aAC/B,WAAW,WAAW,oCACpB,gCAAgC,WAAW,sBAC3C,4BAA4B,WAAW;CAC/C,OAAO;EACL,OAAO,WAAW,WAAW;EAC7B,OAAO,WAAW,WAAW,WAAW,IAAI;EAC5C;EACA,GAAI,cAAc,WAAW,mBAAmB,KAAA,IAC5C,EACE,eAAe;GACb,UAAU,KAAK;GACf,SAAS,WAAW;GAIpB,aAAa,CACX,QAAQ,KAAK,EAAE,CAAC,MAAM,aAAa,KAAK,EAAE,CAAC,MAAM,gCACnD;GACA,gBAAgB,WAAW;EAC7B,EACF,IACA,CAAC;CACP;AACF"}