@tangle-network/agent-eval 0.215.1 → 0.216.1

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

@@ -164,6 +164,12 @@ interface SupervisorRunSources {
   readonly patch: string | null;
   /** Outer-driver log (used for the driver's steer verbs + deadline evidence). */
   readonly driverLog: string | null;
+  /**
+   * Runtime `coordination-log.jsonl` (JSONL of `{ runId, seq, at, event }`):
+   * questions, steers, answers and peer mail between nodes. Absent for stores
+   * that keep no coordination log; null when the Runtime run dir has none.
+   */
+  readonly coordinationLog?: string | null;
   /**
    * Worker tokens recovered from a harness session store; null = store unavailable.
    * `store` names the store in the report's provenance line (e.g. `opencode`).
@@ -561,4 +567,4 @@ interface SupervisorRunTreeGap {
 }
 //#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-DjOMwGY_.d.ts.map
+//# sourceMappingURL=types-BqkVmHfv.d.ts.map

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

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

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

@@ -1,5 +1,5 @@
+import { a as CostLedgerHandle, c as CostLedgerSummary, p as CustomTokenPricing } from "./cost-ledger-Jk62OBfF.js";
 import { t as AgentEvalError } from "./errors-DEE6u6ot.js";
-import { b as CustomTokenPricing, c as CostLedgerHandle, f as CostLedgerSummary, g as CostReceiptInput, x as MaximumCharge } from "./cost-ledger-CO7UyEcQ.js";
 //#region src/judge-families.d.ts
 /**
  * Judge model-family classification + cross-family enforcement.
@@ -286,7 +286,7 @@ declare class FileSystemRawProviderSink implements RawProviderSink {
  */
 declare function providerFromBaseUrl(baseUrl: string): string;
 //#endregion
-//#region src/llm-client.d.ts
+//#region src/llm-client/contract.d.ts
 interface LlmMessage {
   role: 'system' | 'user' | 'assistant' | 'tool';
   /**
@@ -374,7 +374,6 @@ interface LlmChargeBounds {
   /** Token rates used when the provider omits cost or package pricing does not cover the model. */
   customTokenPricing?: CustomTokenPricing;
 }
-declare function maximumChargeForLlmRequest(request: Pick<LlmCallRequest, 'model' | 'messages' | 'jsonSchema' | 'tools' | 'toolChoice' | 'maxTokens' | 'thinking'>, options?: LlmChargeBounds): MaximumCharge | undefined;
 interface LlmUsage {
   promptTokens: number;
   completionTokens: number;
@@ -458,29 +457,6 @@ interface LlmCallResult {
   raw: Record<string, unknown>;
 }
 type LlmCallMetadata = Pick<LlmCallResult, 'usage' | 'costUsd' | 'model' | 'durationMs'>;
-/** Convert a provider result into the canonical paid-call receipt input.
- * The receipt is JSON-clean: absent optional fields are omitted, never carried
- * as explicit-undefined keys. Receipts cross JSON boundaries (the external
- * optimizer's loopback proxy validates them with `assertJsonValue`), where an
- * explicit-undefined value is rejected as non-serializable. */
-declare function costReceiptFromLlm(result: LlmCallResult, customTokenPricing?: CustomTokenPricing): CostReceiptInput;
-/** Structured-response failures retain their completed provider receipt. */
-declare function costReceiptFromLlmError(error: Error, customTokenPricing?: CustomTokenPricing): CostReceiptInput | undefined;
-declare class LlmCallError extends AgentEvalError {
-  readonly status: number;
-  readonly body: string;
-  readonly model: string;
-  constructor(message: string, status: number, body: string, model: string);
-}
-/** A provider response completed and incurred measurable usage, but its content
- *  could not satisfy the caller's response contract. The response envelope is
- *  retained so accounting can commit the receipt before the error propagates. */
-declare class LlmResponseError extends AgentEvalError {
-  readonly result: LlmCallResult;
-  constructor(message: string, result: LlmCallResult, options?: {
-    cause?: unknown;
-  });
-}
 interface LlmClientOptions extends LlmChargeBounds {
   /** Base URL (without trailing slash), ending at the `/v1` prefix. Required: there is no default endpoint. */
   baseUrl?: string;
@@ -557,24 +533,6 @@ interface LlmClientOptions extends LlmChargeBounds {
    */
   assertServedModel?: boolean | AssertServedModelOptions;
 }
-/**
- * True when an error is a transient transport/network fault worth retrying,
- * as opposed to a deterministic failure (4xx schema reject, JSON parse) that
- * a retry cannot fix. Inspects `LlmCallError.status`, then the error's
- * name/message/code, then recurses into `error.cause` — undici nests the
- * real socket fault one or more levels under `.cause`.
- *
- * This is the retry classifier for the package: `callLlm` and
- * `withJudgeRetry` both route through it, so connection failures are treated
- * consistently across transports.
- */
-declare function isTransientLlmError(err: unknown): boolean;
-/**
- * Strip a ```json / ``` code fence if the model emitted one.
- * Idempotent for naked JSON. Some models (claude-code via router, certain
- * deepseek models) wrap output even under json_object.
- */
-declare function stripFencedJson(raw: string): string;
 //#endregion
 //#region src/analyst/chat-client.d.ts
 /**
@@ -868,5 +826,5 @@ interface CheckResult {
   actual: string;
 }
 //#endregion
-export { NoopRawProviderSink as $, createChatClient as A, LlmToolCall as B, ChatResponse as C, judgeFamily as Ct, MockTransportOpts as D, CustomTransportOpts as E, LlmChargeBounds as F, costReceiptFromLlmError as G, LlmToolDefinition as H, LlmMessage as I, stripFencedJson as J, isTransientLlmError as K, LlmResponseError as L, LlmCallMetadata as M, LlmCallRequest as N, OpenAiCompatibleTransportOpts as O, LlmCallResult as P, InMemoryRawProviderSinkOptions as Q, LlmThinkingMode as R, ChatRequest as S, assertCrossFamily as St, CreateChatClientOpts as T, LlmUsage as U, LlmToolChoice as V, costReceiptFromLlm as W, FileSystemRawProviderSinkOptions as X, FileSystemRawProviderSink as Y, InMemoryRawProviderSink as Z, ScenarioResult as _, checkServedModel as _t, CompletionCriterion as a, defaultProviderRedactor as at, ChatCallOpts as b, CrossFamilyError as bt, JudgeInput as c, AssertServedModelOptions as ct, PersonaConfig as d, ServedModelCheck as dt, ProviderRedactor as et, ProductClientConfig as f, ServedModelPolicy as ft, ScenarioFile as g, assertServedModels as gt, Scenario as h, assertServedModel as ht, CollectedArtifacts as i, RawProviderSinkFilter as it, LlmCallError as j, SandboxSdkTransportOpts as k, JudgeRubric as l, ModelSubstitutionError as lt, RubricDimension as m, assertCrossFamilyServed as mt, ArtifactResult as n, RawProviderEvent as nt, DriverState as o, providerFromBaseUrl as ot, RouteMap as p, ServedModelVerdict as pt, maximumChargeForLlmRequest as q, CheckResult as r, RawProviderSink as rt, JudgeFn as s, AssertCrossFamilyServedOptions as st, ArtifactCheck as t, RawProviderDirection as tt, JudgeScore as u, ServedCrossFamilyError as ut, Turn as v, servedModelAcceptable as vt, ChatTransport as w, ChatClient as x, JudgeFamily as xt, TurnResult as y, AssertCrossFamilyOptions as yt, LlmTokenLogprob as z };
-//# sourceMappingURL=types-DBZ7keha.d.ts.map
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-C02qtnG8.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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"}

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

@@ -1,6 +1,7 @@
-import { c as CostLedgerHandle, p as CostProvenance } from "./cost-ledger-CO7UyEcQ.js";
-import { a as RunRecord, d as RunTokenUsage } from "./run-record-D1Hw-Jml.js";
-import { c as JudgeInput, x as ChatClient } from "./types-DBZ7keha.js";
+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 { z } from "zod";
 import { SpanKind } from "@tangle-network/agent-trace-contract";
 import { RE2JS } from "re2js";
 //#region src/trace-analyst/types.d.ts
@@ -289,13 +290,326 @@ interface BoundedTraceAnalysisStoreOptions {
 /** Apply the public validation, cancellation, not-found, and size rules to any adapter. */
 declare function createBoundedTraceAnalysisStore(source: TraceAnalysisStore, options?: BoundedTraceAnalysisStoreOptions): TraceAnalysisStore;
 //#endregion
+//#region src/analyst/finding-scope.d.ts
+/**
+ * The layer ladder, lowest first. `problem` is what discovery-lab calls a
+ * theatre. `meta` sits outside the ladder: it is about the instrument, not the
+ * agents, so it never promotes and never bounds another layer.
+ */
+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
+   * query: the ids are what `n`, `evidence_units` and promotion's lineage
+   * check are compared against, and a query re-run later can select a
+   * different set. Select populations with `queryFindings` (layer, subject,
+   * domain path, analyst) and store the ids it returned.
+   */
+  population: string[];
+  /** Units measured. Below 2, readers label the finding an anecdote. */
+  n: number;
+  /** ISO-8601 bounds of the measured activity. */
+  window: {
+    from: string;
+    to: string;
+  };
+  /** Domain taxonomy path of any depth, broadest first. */
+  domain_path?: string[];
+}
+interface FindingCalibration {
+  /** Gold items the judge was scored against. */
+  gold_n: number;
+  /** Share of gold items where the judge matched the gold label. */
+  agreement: number;
+  /** Chance-corrected agreement (Cohen's κ). */
+  kappa: number;
+}
+interface FindingMethod {
+  kind: 'computed' | 'measured' | 'judged';
+  name: string;
+  version: string;
+  calibration?: FindingCalibration;
+}
+interface FindingMeasure {
+  name: string;
+  value: number;
+  unit: string;
+  interval?: [number, number];
+  /** Confidence level of `interval`, in (0, 1). */
+  level?: number;
+}
+/**
+ * One measured unit. `derived_from` is the unit this one inherited state from
+ * (run 2 built on run 1's code): `null` records an independent start, and an
+ * absent field records lineage nobody captured. Unknown lineage counts as
+ * shared, so it can never manufacture independent support for a claim.
+ */
+interface FindingEvidenceUnit {
+  id: string;
+  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<{
+    "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>>>;
+  proposal_origin: z.ZodEnum<{
+    production: "production";
+    search: "search";
+  }>;
+}, z.core.$strict>;
+type FindingParseOutcome = {
+  succeeded: true;
+  value: AnalystFinding;
+} | {
+  succeeded: false;
+  error: {
+    path: string;
+    message: string;
+  };
+};
+/** Validate one stored finding of schema 1.0.0 or 1.1.0. */
+declare function parseAnalystFinding(value: unknown): FindingParseOutcome;
+/**
+ * A finding's scope as a reader sees it. A 1.0.0 finding states neither layer
+ * nor population, so both read `unknown` — never a guessed value.
+ */
+interface FindingScopeReading {
+  layer: FindingLayer | 'unknown';
+  n: number | 'unknown';
+  /** Units with distinct lineage roots; unknown lineage counts as one shared root. */
+  independent_n: number | 'unknown';
+  domain_path: readonly string[] | null;
+  labels: FindingReaderLabel[];
+}
+/**
+ * - `unscoped`: a 1.0.0 finding with no layer or population.
+ * - `anecdote`: measured on fewer than two units.
+ * - `uncalibrated`: judged, with no calibration against gold labels.
+ * - `lineage-unknown`: at least one unit has no recorded lineage.
+ */
+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
+ * the list takes that id as its root; unknown lineage maps to one shared root.
+ */
+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
 /**
  * Unified envelope every analyst emits. Schema-versioned so renderers
  * and time-series diffs survive future field additions.
+ *
+ * 1.1.0 adds what a finding is about and what it was measured on: `layer`,
+ * `scope`, `method`, `measure`, `confounders`, `valid_for`, `claim_id` and
+ * `evidence_units`. They are all optional, and a 1.0.0 finding carries none of
+ * them; `readFindingScope` reads such a finding as layer and n unknown.
+ * `parseAnalystFinding` (finding-scope.ts) is the one validator for both.
  */
 interface AnalystFinding {
-  schema_version: '1.0.0';
+  schema_version: AnalystFindingSchemaVersion;
   /**
    * Stable hash over identity-defining fields (analyst_id + canonical
    * claim + area + optional subject). Two findings from two runs that
@@ -332,7 +646,32 @@ interface AnalystFinding {
   derived_from_judge?: boolean;
   /** Analyst-private extras; renderers ignore unless they know the analyst. */
   metadata?: Record<string, unknown>;
+  /** 1.1.0: the level the claim is about, from one event up to the whole lab. */
+  layer?: FindingLayer;
+  /** 1.1.0: the population the claim was measured on. */
+  scope?: FindingScope;
+  /** 1.1.0: how the claim was produced, and the judge's calibration when judged. */
+  method?: FindingMethod;
+  /** 1.1.0: the number behind the claim, when it has one. */
+  measure?: FindingMeasure;
+  /** 1.1.0: known differences between the compared units besides the treatment. */
+  confounders?: string[];
+  /** 1.1.0: the conditions the claim was measured under, in words. */
+  valid_for?: string;
+  /**
+   * 1.1.0: stable key for the claim across subjects and layers. `promote`
+   * groups children by it; a finding without one never lifts.
+   */
+  claim_id?: string;
+  /**
+   * 1.1.0: the measured units with their lineage. When present, `scope.n` and
+   * `scope.population` must match them and no unit may sit above `layer`.
+   */
+  evidence_units?: FindingEvidenceUnit[];
 }
+/** Every finding schema this package reads. Writers emit 1.1.0 only when a 1.1.0 field is set. */
+declare const ANALYST_FINDING_SCHEMA_VERSIONS: readonly ['1.0.0', '1.1.0'];
+type AnalystFindingSchemaVersion = (typeof ANALYST_FINDING_SCHEMA_VERSIONS)[number];
 /** Finding severity. `AnalystSeverity` derives from this array, so the type
  *  and the schema that validates a finding cannot name different levels. */
 declare const ANALYST_SEVERITIES: readonly ['critical', 'high', 'medium', 'low', 'info'];
@@ -549,6 +888,8 @@ 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.
@@ -629,5 +970,5 @@ type AnalystRunEvent = {
   result: AnalystRunResult;
 };
 //#endregion
-export { DEFAULT_TRACE_ANALYST_BUDGETS as A, TraceAnalystSpan as B, BoundedTraceAnalysisStoreOptions as C, TRACE_ANALYSIS_LIMITS as D, SpanSourceReader as E, SearchTraceResult as F, ViewTraceOversized as G, TraceAnalystSpanStatus as H, SpanMatchRecord as I, ViewTraceResult as K, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as L, ErrorCluster as M, QueryTracesPage as N, TraceAnalysisStore as O, SearchSpanResult as P, TraceAnalystByteBudgets as R, createBoundedTraceAnalysisStore as S, ReadSpanSourceResult as T, TraceAnalystTraceSummary as U, TraceAnalystSpanKind as V, ViewSpansResult as W, ProposalFinding as _, AnalystInputKind as a, makeFinding as b, AnalystRunInputs as c, AnalystSeverity as d, AnalystUsageReceipt as f, ExecutionProbeRequest as g, ExecutionProbeOutcome as h, AnalystFinding as i, DatasetOverview as j, TraceAnalysisStoreContext as k, AnalystRunResult as l, ExecutionProbe as m, AnalystContext as n, AnalystRequirements as o, EvidenceRef as p, AnalystCost as r, AnalystRunEvent as s, Analyst as t, AnalystRunSummary as u, ProposalFindingOrigin as v, ReadSpanSourceInput as w, makeProposalFinding as x, computeFindingId as y, TraceAnalystFilters as z };
-//# sourceMappingURL=types-DHb5TI36.d.ts.map
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-C1tnkEgM.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":"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"}

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

@@ -1,5 +1,5 @@
-import { c as RunSplitTag } from "./run-record-D1Hw-Jml.js";
-import { R as Scenario, d as DispatchContext } from "./types-CGEmVYOk.js";
+import { c as RunSplitTag } from "./run-record-C1E24G2A.js";
+import { R as Scenario, d as DispatchContext } from "./types-Cq8mSbq8.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-DinHtRJp.d.ts.map
+//# sourceMappingURL=types-Cbe2fWBa.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types-DinHtRJp.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-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"}