@tangle-network/agent-eval 0.221.7 → 0.222.0

package/dist/{types-B_IFcKp5.d.ts → types-0KglnQ9o.d.ts}

@@ -1,6 +1,5 @@
-import { l as CostLedgerSummary, m as CustomTokenPricing, o as CostLedgerHandle } from "./cost-ledger-C1W3ICmP.js";
-import { t as AgentEvalError } from "./errors-DEE6u6ot.js";
-//#region src/judge-families.d.ts
+import { l as CostLedgerSummary, m as CustomTokenPricing, o as CostLedgerHandle } from "./cost-ledger-Czro9wmo.js";
+import { t as AgentEvalError } from "./errors-E9I2hldP.js";
 /**
  * Judge model-family classification + cross-family enforcement.
  *
@@ -46,8 +45,6 @@ declare class CrossFamilyError extends Error {
  * ./integrity/served-model.
  */
 declare function assertCrossFamily(models: string[], opts?: AssertCrossFamilyOptions): JudgeFamily[];
-//#endregion
-//#region src/integrity/served-model.d.ts
 /** How a served id relates to the id that was requested. */
 type ServedModelVerdict =
 /** Byte-identical after normalisation — the requested model answered. */
@@ -153,8 +150,6 @@ declare function assertCrossFamilyServed(pairs: ReadonlyArray<{
   requested: string;
   served: string | null | undefined;
 }>, opts?: AssertCrossFamilyServedOptions): JudgeFamily[];
-//#endregion
-//#region src/trace/raw-provider-sink.d.ts
 /**
  * RawProviderSink — first-class persistence for the actual HTTP-level
  * request/response bodies of every LLM provider call.
@@ -274,8 +269,6 @@ declare class FileSystemRawProviderSink implements RawProviderSink {
   record(event: RawProviderEvent): Promise<void>;
   list(filter?: RawProviderSinkFilter): Promise<RawProviderEvent[]>;
 }
-//#endregion
-//#region src/llm-client/contract.d.ts
 interface LlmMessage {
   role: 'system' | 'user' | 'assistant' | 'tool';
   /**
@@ -522,8 +515,6 @@ interface LlmClientOptions extends LlmChargeBounds {
    */
   assertServedModel?: boolean | AssertServedModelOptions;
 }
-//#endregion
-//#region src/analyst/chat-client.d.ts
 /**
  * Unified chat interface using the package's canonical LLM request and result.
  */
@@ -617,8 +608,6 @@ interface MockTransportOpts extends BaseTransportOpts {
  * is safe to share across analysts in a single registry run.
  */
 declare function createChatClient(opts: CreateChatClientOpts): ChatClient;
-//#endregion
-//#region src/types.d.ts
 interface ProductScenario {
   id: string;
   persona: string;
@@ -814,6 +803,5 @@ interface CheckResult {
   expected: string;
   actual: string;
 }
-//#endregion
 export { AssertCrossFamilyServedOptions as $, createChatClient as A, LlmToolChoice as B, ChatResponse as C, MockTransportOpts as D, CustomTransportOpts as E, LlmClientOptions as F, InMemoryRawProviderSink as G, LlmUsage as H, LlmMessage as I, ProviderRedactor as J, InMemoryRawProviderSinkOptions as K, LlmThinkingMode as L, LlmCallRequest as M, LlmCallResult as N, OpenAiCompatibleTransportOpts as O, LlmChargeBounds as P, RawProviderSinkFilter as Q, LlmTokenLogprob as R, ChatRequest as S, CreateChatClientOpts as T, FileSystemRawProviderSink as U, LlmToolDefinition as V, FileSystemRawProviderSinkOptions as W, RawProviderEvent as X, RawProviderDirection as Y, RawProviderSink as Z, ScenarioResult as _, CompletionCriterion as a, assertCrossFamilyServed as at, ChatCallOpts as b, JudgeFn as c, checkServedModel as ct, PersonaConfig as d, CrossFamilyError as dt, AssertServedModelOptions as et, ProductClientConfig as f, JudgeFamily as ft, ScenarioFile as g, RubricDimension as h, CollectedArtifacts as i, ServedModelVerdict as it, LlmCallMetadata as j, SandboxSdkTransportOpts as k, JudgeInput as l, describeServedModelCheck as lt, RouteMap as m, judgeFamily as mt, ArtifactResult as n, ServedModelCheck as nt, DimensionJudgeScore as o, assertServedModel as ot, ProductScenario as p, assertCrossFamily as pt, NoopRawProviderSink as q, CheckResult as r, ServedModelPolicy as rt, DriverState as s, assertServedModels as st, ArtifactCheck as t, ModelSubstitutionError as tt, JudgeRubric as u, AssertCrossFamilyOptions as ut, Turn as v, ChatTransport as w, ChatClient as x, TurnResult as y, LlmToolCall as z };
-//# sourceMappingURL=types-B_IFcKp5.d.ts.map
+//# sourceMappingURL=types-0KglnQ9o.d.ts.map

package/dist/types-0KglnQ9o.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-0KglnQ9o.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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;;iBAO9C,iBAAiB,MAAM,uBAAuB;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-DZ0mYVw9.d.ts → types-0oMg7zee.d.ts}

@@ -1,6 +1,5 @@
-import { c as RunSplitTag } from "./run-record-C3awiXPf.js";
-import { R as Scenario, d as DispatchContext } from "./types-M6eF9m-r.js";
-//#region src/benchmarks/types.d.ts
+import { c as RunSplitTag } from "./run-record-D2BFMPGl.js";
+import { R as Scenario, d as DispatchContext } from "./types-C54Uk_a1.js";
 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';
 interface BenchmarkDatasetItem<TPayload = unknown> {
@@ -97,6 +96,5 @@ declare const BENCHMARK_SPLIT_SEED = "agent-eval-v1";
  *   holdout:20%   (paper-grade held-out, gated reads)
  */
 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-DZ0mYVw9.d.ts.map
+//# sourceMappingURL=types-0oMg7zee.d.ts.map

package/dist/types-0oMg7zee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-0oMg7zee.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/{types-CnWmj8NW.js → types-BK0blWhe.js}

@@ -1,6 +1,6 @@
-import { o as mergeFindingComposition, r as findingCompositionKey } from "./finding-composition-8n0fFgVI.js";
+import { o as mergeFindingComposition, r as findingCompositionKey } from "./finding-composition-DlvE1Qul.js";
 import { createHash } from "node:crypto";
-//#region src/analyst/types.ts
+// src/analyst/types.ts
 /**
 * Analyst contract — the missing orchestration layer over agent-eval's
 * existing analyzers (analyzeTraces, MultiLayerVerifier,
@@ -96,7 +96,6 @@ function makeProposalFinding(init) {
 		proposal_origin
 	};
 }
-//#endregion
 export { makeProposalFinding as a, makeFinding as i, FINDING_SCOPE_FIELDS as n, computeFindingId as r, ANALYST_SEVERITIES as t };
 
-//# sourceMappingURL=types-CnWmj8NW.js.map
+//# sourceMappingURL=types-BK0blWhe.js.map

package/dist/{types-CnWmj8NW.js.map → types-BK0blWhe.js.map}

@@ -1 +1 @@
-{"version":3,"file":"types-CnWmj8NW.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 {\n  type FindingConditions,\n  type FindingTreatment,\n  findingCompositionKey,\n  mergeFindingComposition,\n} from './finding-composition'\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`, with optional `treatment` and `conditions` composition. 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  /** Deliberately assigned bundles; every bundle may touch several treatment layers. */\n  treatment?: FindingTreatment[]\n  /** Observed condition snapshots with population and observation-time provenance. */\n  conditions?: FindingConditions[]\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 * Legacy identity hashes {analyst_id, area, subject, normalized claim}. Supplied\n * composition adds normalized treatment/fixed-condition identity; covariate provenance\n * remains on the record without making every observation time a different 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  treatment?: FindingTreatment[]\n  conditions?: FindingConditions[]\n}): string {\n  const composition = findingCompositionKey(input)\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    ...(composition ? { composition } : {}),\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  'treatment',\n  'conditions',\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, ...fields } = init\n  const rest = { ...fields, ...mergeFindingComposition([fields]) }\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      treatment: rest.treatment,\n      conditions: rest.conditions,\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":";;;;;;;;;;;;;;;;;;;;;AAwHA,MAAa,qBAAqB;CAAC;CAAY;CAAQ;CAAU;CAAO;AAAM;;;;;;;;;;;AAmO9E,SAAgB,iBAAiB,OAStB;CACT,MAAM,cAAc,sBAAsB,KAAK;CAC/C,MAAM,QAAQ,KAAK,UAAU;EAC3B,GAAG,MAAM;EACT,GAAG,MAAM;EACT,GAAG,MAAM,WAAW;EACpB,GAAG,eAAe,MAAM,YAAY,MAAM,KAAK;EAC/C,GAAI,cAAc,EAAE,YAAY,IAAI,CAAC;CACvC,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;CACA;CACA;AACF;;;;;AAMA,SAAgB,YACd,MAIgB;CAChB,MAAM,EAAE,UAAU,aAAa,GAAG,WAAW;CAC7C,MAAM,OAAO;EAAE,GAAG;EAAQ,GAAG,wBAAwB,CAAC,MAAM,CAAC;CAAE;CAC/D,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;GACA,WAAW,KAAK;GAChB,YAAY,KAAK;EACnB,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"}
+{"version":3,"file":"types-BK0blWhe.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 {\n  type FindingConditions,\n  type FindingTreatment,\n  findingCompositionKey,\n  mergeFindingComposition,\n} from './finding-composition'\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`, with optional `treatment` and `conditions` composition. 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  /** Deliberately assigned bundles; every bundle may touch several treatment layers. */\n  treatment?: FindingTreatment[]\n  /** Observed condition snapshots with population and observation-time provenance. */\n  conditions?: FindingConditions[]\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 * Legacy identity hashes {analyst_id, area, subject, normalized claim}. Supplied\n * composition adds normalized treatment/fixed-condition identity; covariate provenance\n * remains on the record without making every observation time a different 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  treatment?: FindingTreatment[]\n  conditions?: FindingConditions[]\n}): string {\n  const composition = findingCompositionKey(input)\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    ...(composition ? { composition } : {}),\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  'treatment',\n  'conditions',\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, ...fields } = init\n  const rest = { ...fields, ...mergeFindingComposition([fields]) }\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      treatment: rest.treatment,\n      conditions: rest.conditions,\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":";;;;;;;;;;;;;;;;;;;;;AAwHA,MAAa,qBAAqB;CAAC;CAAY;CAAQ;CAAU;CAAO;AAAM;;;;;;;;;;;AAmO9E,SAAgB,iBAAiB,OAStB;CACT,MAAM,cAAc,sBAAsB,KAAK;CAC/C,MAAM,QAAQ,KAAK,UAAU;EAC3B,GAAG,MAAM;EACT,GAAG,MAAM;EACT,GAAG,MAAM,WAAW;EACpB,GAAG,eAAe,MAAM,YAAY,MAAM,KAAK;EAC/C,GAAI,cAAc,EAAE,YAAY,IAAI,CAAC;CACvC,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;CACA;CACA;AACF;;;;;AAMA,SAAgB,YACd,MAIgB;CAChB,MAAM,EAAE,UAAU,aAAa,GAAG,WAAW;CAC7C,MAAM,OAAO;EAAE,GAAG;EAAQ,GAAG,wBAAwB,CAAC,MAAM,CAAC;CAAE;CAC/D,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;GACA,WAAW,KAAK;GAChB,YAAY,KAAK;EACnB,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-CmXY0PQf.d.ts → types-C-aOqgt2.d.ts}

@@ -1,6 +1,4 @@
-import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
-import { C as RolloutWorkspaceCapture, h as RolloutLine } from "./schema-C-ziyJD7.js";
-//#region src/supervisor-run/types.d.ts
+import { C as RolloutWorkspaceCapture, L as SeriesDistribution, h as RolloutLine } from "./schema-DkFJr3Y8.js";
 /** A metric that could not be computed, with the reason its artifact was missing. */
 interface Unavailable {
   readonly unavailable: string;
@@ -563,6 +561,5 @@ interface SupervisorRunTreeGap {
   readonly nodeId?: string;
   readonly count?: number;
 }
-//#endregion
 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
+//# sourceMappingURL=types-C-aOqgt2.d.ts.map

package/dist/types-C-aOqgt2.d.ts.map

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

package/dist/{types-M6eF9m-r.d.ts → types-C54Uk_a1.d.ts}

@@ -1,20 +1,18 @@
-import { g as PaidCallResult, i as CostChannel, l as CostLedgerSummary, o as CostLedgerHandle, r as CostBreakdown, u as CostProvenance, y as RunPaidCallInput } from "./cost-ledger-C1W3ICmP.js";
-import { d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-C3awiXPf.js";
-import { v as ProposalFinding } from "./types-6Lfdlshp.js";
-import { j as LlmCallMetadata } from "./types-B_IFcKp5.js";
-import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
-import { A as SearchLedgerHash, F as SearchNodeRegisteredEvent, 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 { y as LedgerProjector } from "./index-CalAsXMR.js";
-import { i as RolloutSearchLineage } from "./mint-CkzpVPdz.js";
-//#region src/campaign/search-state-identity.d.ts
+import { g as PaidCallResult, i as CostChannel, l as CostLedgerSummary, o as CostLedgerHandle, r as CostBreakdown, u as CostProvenance, y as RunPaidCallInput } from "./cost-ledger-Czro9wmo.js";
+import { a as RunRecord, d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-D2BFMPGl.js";
+import { v as ProposalFinding } from "./types-DzCO-S1m.js";
+import { j as LlmCallMetadata } from "./types-0KglnQ9o.js";
+import { L as SeriesDistribution, a as MintedRolloutLine, m as RolloutEvidenceAttempt, t as ChatMessage, y as RolloutRole } from "./schema-DkFJr3Y8.js";
+import { A as SearchLedgerHash, F as SearchNodeRegisteredEvent, 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-qiYRUo_N.js";
+import { y as LedgerProjector } from "./index-B1Bm9oJA.js";
+import { s as TraceStore } from "./store-CMs5wGXP.js";
+import "./reward-ST4PXNXF.js";
 /** Deterministic node id: identical content in one search is one node. */
 declare function searchNodeId(searchId: string, artifactDigest: string): string;
 /** Deterministic cell id: one node on one task in one split at one repeat. */
 declare function searchCellId(searchId: string, nodeId: string, taskId: string, split: SearchSplit, rep: number): string;
 /** Digest a split's task list in taskId order. */
 declare function searchTaskSetDigest(tasks: readonly SearchTask[]): SearchLedgerHash;
-//#endregion
-//#region src/campaign/search-state-types.d.ts
 interface SearchDecisionRecord {
   sequence: number;
   decision: SearchNodeDecision;
@@ -137,8 +135,6 @@ interface NodeRecord {
   scoredCells: number;
   spend: SearchSpend;
 }
-//#endregion
-//#region src/campaign/search-state-indexes.d.ts
 declare class SearchLedgerIndexes {
   readonly tasks: Map<string, {
     split: SearchSplit;
@@ -162,8 +158,79 @@ declare class SearchLedgerIndexes {
   operation(operationId: string): SearchOperation | undefined;
   scoredCells(nodeId: string, split: SearchSplit): SearchScoredCell[];
 }
-//#endregion
-//#region src/campaign/search-state-view.d.ts
+/** Redactor for transcript/step payload text (secrets, PII), not opaque identity. */
+type RolloutScrubber = (text: string) => string;
+/** A search cell's place in its search tree, read from the search ledger. */
+interface RolloutSearchLineage {
+  /** Edges between the cell's node and the search root; the root is 0. */
+  depth: number;
+  /** Order in which the node registered in its search; the root is 0. */
+  ordinal: number;
+  /** Repeat index of the cell on its task, from 0. */
+  rep: number;
+  /** Run id of the cell whose execution contains this search; null for a
+   *  top-level search. */
+  containingRunId: string | null;
+}
+interface MintRolloutOptions {
+  scrub?: RolloutScrubber;
+  /**
+   * Full canonical capture, including turns no longer in the model's context.
+   * When supplied, missing/empty capture is refused, never replaced with a
+   * span summary. Use the execution owner's capture or the existing harness
+   * readers; reviewer traces and compacted histories are not full capture.
+   */
+  messagesOf?: (runId: string) => readonly ChatMessage[] | undefined | Promise<readonly ChatMessage[] | undefined>;
+  /** Provider attempts from a retained receipt bound to the exact run. */
+  evidenceOf?: (runId: string) => {
+    runId: string;
+    attempts: readonly RolloutEvidenceAttempt[];
+  } | undefined | Promise<{
+    runId: string;
+    attempts: readonly RolloutEvidenceAttempt[];
+  } | undefined>;
+  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */
+  maxSteps?: number;
+  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */
+  role?: RolloutRole;
+  /** Task suite label. Default: the record's `experimentId`. */
+  suite?: string;
+  /** Injected clock for deterministic output. */
+  now?: () => Date;
+  /**
+   * Lineage of a search run, read from its search ledger. It fills the line's
+   * `generation` (node depth), `candidate_index` (node order), `task.rep` and
+   * `parent_rollout_id` (the containing cell's run). Mint refuses a record
+   * that carries `search` when this is absent, because a null `generation`
+   * states that the run is not part of a search.
+   */
+  searchLineage?: (search: RunSearchCoordinates) => RolloutSearchLineage | Promise<RolloutSearchLineage>;
+}
+interface MintRolloutResult {
+  rows: MintedRolloutLine[];
+  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */
+  missingTraces: string[];
+}
+/**
+ * Why a record cannot be minted, one entry per missing field, empty when it can.
+ *
+ * Exported so a caller can partition a whole ledger — "which of my 2742 records
+ * predate 0.126" — without catching an exception per record, and without
+ * re-deriving the field list on their side. A re-derived list is a list that
+ * drifts from the door it is supposed to predict.
+ *
+ * Takes a `RunRecord` because that is what the caller holds and what the
+ * compiler agrees they hold. The type is precisely the thing that is wrong, so
+ * the checks read the record as the untyped bag it actually is on disk.
+ */
+declare function unmintableReasons(record: RunRecord): string[];
+/**
+ * Join RunRecords with their traces into canonical rollout lines. Records
+ * without spans or an explicit capture are emitted as labeled gap lines and reported in
+ * `missingTraces`. Execution-only records without a task score are rejected
+ * because a missing training label is not a zero reward.
+ */
+declare function mintRolloutRows(records: RunRecord[], store: TraceStore, options?: MintRolloutOptions): Promise<MintRolloutResult>;
 /**
  * Per-unit means of scored cells, in unitId order. Each unit sums its cells in
  * cellId order, so the result depends on the set of cells alone, never on the
@@ -228,8 +295,6 @@ declare class SearchStateView {
   lineage(coordinates: RunSearchCoordinates): RolloutSearchLineage;
   private live;
 }
-//#endregion
-//#region src/campaign/search-state-projection.d.ts
 /**
  * The pure, incremental projection of one search ledger. `apply` refuses any
  * entry that breaks an invariant; the journal then discards this instance and
@@ -291,8 +356,6 @@ declare class SearchState implements LedgerProjector<SearchLedgerEntry, SearchSt
     };
   };
 }
-//#endregion
-//#region src/campaign/search-summary.d.ts
 /** The proposer's own read of a search: its node's cells on the train split,
  * the only split a proposer may ever see. */
 interface SearchProposerView {
@@ -328,8 +391,6 @@ interface SearchSummaryOptions {
  * state already in hand).
  */
 declare function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string;
-//#endregion
-//#region src/campaign/types.d.ts
 /** Stable identifier + kind tag for any scenario. Consumers
  *  extend with their per-domain payload (persona, task, requirement, ...). */
 interface Scenario {
@@ -1015,6 +1076,5 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
    *  without retaining customer task content in the result. */
   scenarios: Array<CampaignScenarioIdentity & Pick<TScenario, 'id' | 'kind'>>;
 }
-//#endregion
-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-M6eF9m-r.d.ts.map
+export { MintRolloutResult 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, MintRolloutOptions 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, SearchCompletion as at, GenerationRecord as b, CampaignTraceWriter as c, SearchOperation as ct, DispatchContext as d, SearchUnitScore as dt, RolloutScrubber as et, DispatchFn as f, searchCellId as ft, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchCell as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, SearchScoredCell as lt, GateCheckStatus as m, searchTaskSetDigest as mt, CampaignArtifactWriter as n, mintRolloutRows as nt, CampaignScenarioIdentity as o, SearchDecisionRecord as ot, Gate as p, searchNodeId as pt, renderSearchSummary as q, CampaignCellResult as r, unmintableReasons as rt, CampaignTokenUsage as s, SearchNode as st, CampaignAggregates as t, RolloutSearchLineage as tt, ComponentSurface as u, SearchSpend as ut, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
+//# sourceMappingURL=types-C54Uk_a1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-C54Uk_a1.d.ts","names":[],"sources":["../src/campaign/search-state-identity.ts","../src/campaign/search-state-types.ts","../src/campaign/search-state-indexes.ts","../src/rollout/mint.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-BXgASBCL.js → types-DK4vNv5q.js}

@@ -1,4 +1,4 @@
-//#region src/multishot/types.ts
+// src/multishot/types.ts
 var MultishotDriverEmptyError = class extends Error {
 	turn;
 	constructor(turn) {
@@ -102,7 +102,6 @@ function describeValue(value) {
 	if (typeof value === "object") return "an object";
 	return `${typeof value} ${String(value)}`;
 }
-//#endregion
 export { MultishotFatalToolError as n, assertMultishotShotResult as r, MultishotDriverEmptyError as t };
 
-//# sourceMappingURL=types-BXgASBCL.js.map
+//# sourceMappingURL=types-DK4vNv5q.js.map

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

@@ -1 +1 @@
-{"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":";AAmHA,IAAa,4BAAb,cAA+C,MAAM;CACvB;CAA5B,YAAY,MAA8B;EACxC,MAAM,0DAA0D,KAAK,gBAAgB;EAD3D,KAAA,OAAA;EAE1B,KAAK,OAAO;CACd;AACF;AAEA,IAAa,0BAAb,cAA6C,MAAM;CACjD,YAAY,SAAiB;EAC3B,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF;AAEA,IAAa,2BAAb,cAA8C,MAAM;CAClD,YAAY,QAAgB;EAC1B,MAAM,yDAAyD,QAAQ;EACvE,KAAK,OAAO;CACd;AACF;AAEA,MAAM,kCAAkB,IAAI,IAAI;CAAC;CAAQ;CAAa;AAAM,CAAC;;;;;;;;;;;;;;;;;;AAmB7D,SAAgB,0BAA0B,OAAkD;CAC1F,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,MAAM,IAAI,yBAAyB,gCAAgC,cAAc,KAAK,GAAG;CAE3F,MAAM,SAAS;CACf,IAAI,CAAC,MAAM,QAAQ,OAAO,UAAU,GAClC,MAAM,IAAI,yBACR,yCAAyC,cAAc,OAAO,UAAU,GAC1E;CAEF,IAAI,CAAC,MAAM,QAAQ,OAAO,SAAS,GACjC,MAAM,IAAI,yBACR,wCAAwC,cAAc,OAAO,SAAS,GACxE;CAEF,OAAO,WAAW,QAAQ,aAAa;CACvC,OAAO,UAAU,QAAQ,cAAc;CACvC,kBAAkB,OAAO,WAAW,WAAW;CAC/C,kBAAkB,OAAO,YAAY,YAAY;CACjD,kBAAkB,OAAO,SAAS,SAAS;CAC3C,IAAI,OAAO,mBAAmB,KAAA,GAAW,qBAAqB,OAAO,cAAc;AACrF;AAEA,SAAS,qBAAqB,OAAsB;CAClD,MAAM,MAAM,WAAW,OAAO,gBAAgB;CAC9C,IAAI,IAAI,SAAS,cAAc,IAAI,SAAS,eAAe,IAAI,SAAS,cACtE,MAAM,IAAI,yBACR,2EAA2E,cAAc,IAAI,IAAI,GACnG;CAIF,IAAI,IAAI,SAAS,cAAc;EAC7B,IAAI,IAAI,QAAQ,MACd,MAAM,IAAI,yBACR,wDAAwD,cAAc,IAAI,GAAG,GAC/E;EAEF;CACF;CACA,kBAAkB,IAAI,KAAK,oBAAoB;AACjD;AAEA,SAAS,cAAc,OAAgB,OAAqB;CAC1D,MAAM,MAAM,WAAW,OAAO,cAAc,MAAM,EAAE;CACpD,IAAI,OAAO,IAAI,SAAS,YAAY,CAAC,gBAAgB,IAAI,IAAI,IAAI,GAC/D,MAAM,IAAI,yBACR,cAAc,MAAM,mDAAmD,cAAc,IAAI,IAAI,GAC/F;CAEF,aAAa,IAAI,SAAS,cAAc,MAAM,UAAU;CACxD,IAAI,IAAI,eAAe,KAAA,GACrB,aAAa,IAAI,YAAY,cAAc,MAAM,aAAa;CAEhE,IAAI,IAAI,cAAc,KAAA,GAAW;CACjC,IAAI,CAAC,MAAM,QAAQ,IAAI,SAAS,GAC9B,MAAM,IAAI,yBACR,cAAc,MAAM,sDAAsD,cAAc,IAAI,SAAS,GACvG;CAEF,IAAI,UAAU,SAAS,MAAM,cAAc;EACzC,MAAM,QAAQ,cAAc,MAAM,cAAc,UAAU;EAC1D,MAAM,MAAM,WAAW,MAAM,KAAK;EAClC,aAAa,IAAI,IAAI,GAAG,MAAM,IAAI;EAClC,aAAa,IAAI,MAAM,GAAG,MAAM,MAAM;EACtC,WAAW,IAAI,MAAM,GAAG,MAAM,MAAM;CACtC,CAAC;AACH;AAEA,SAAS,eAAe,OAAgB,OAAqB;CAC3D,MAAM,MAAM,WAAW,OAAO,aAAa,MAAM,EAAE;CACnD,aAAa,IAAI,MAAM,aAAa,MAAM,OAAO;CACjD,aAAa,IAAI,SAAS,aAAa,MAAM,UAAU;CACvD,kBAAkB,IAAI,MAAM,aAAa,MAAM,OAAO;CACtD,MAAM,aAAa,WAAW,IAAI,YAAY,aAAa,MAAM,aAAa;CAC9E,aAAa,WAAW,MAAM,aAAa,MAAM,kBAAkB;CACnE,WAAW,WAAW,MAAM,aAAa,MAAM,kBAAkB;AACnE;AAEA,SAAS,WAAW,OAAgB,OAAwC;CAC1E,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,MAAM,IAAI,yBACR,GAAG,MAAM,+BAA+B,cAAc,KAAK,GAC7D;CAEF,OAAO;AACT;AAEA,SAAS,aAAa,OAAgB,OAAqB;CACzD,IAAI,OAAO,UAAU,UACnB,MAAM,IAAI,yBACR,GAAG,MAAM,8BAA8B,cAAc,KAAK,GAC5D;AAEJ;AAEA,SAAS,kBAAkB,OAAgB,OAAqB;CAC9D,IAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,KAAK,QAAQ,GAClE,MAAM,IAAI,yBACR,GAAG,MAAM,0CAA0C,cAAc,KAAK,GACxE;AAEJ;AAEA,SAAS,cAAc,OAAwB;CAC7C,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO;CACjC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,OAAO,GAAG,OAAO,MAAM,GAAG,OAAO,KAAK;AACxC"}
+{"version":3,"file":"types-DK4vNv5q.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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"}