@tangle-network/agent-eval 0.215.0 → 0.216.0

package/dist/{types-KEkKkETv.d.ts → types-oKRhQAde.d.ts}

@@ -1,6 +1,7 @@
-import { c as CostLedgerHandle, p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { a as RunRecord, d as RunTokenUsage } from "./run-record-p2AYTrCn.js";
-import { c as JudgeInput, x as ChatClient } from "./types-Lub7o6bN.js";
+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 { 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-KEkKkETv.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-oKRhQAde.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-oKRhQAde.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/wire/index.d.ts

@@ -1,7 +1,7 @@
-import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-DbQdN3nO.js";
-import { x as ChatClient } from "../types-Lub7o6bN.js";
+import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-CO7UyEcQ.js";
+import { x as ChatClient } from "../types-DBZ7keha.js";
 import { s as TraceStore } from "../store-C4avFjIi.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-CX01700m.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DkaDj0dj.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";

package/dist/wire/index.js

@@ -1,2 +1,2 @@
-import { A as WIRE_VERSION, C as RUBRIC_VERSION_SCHEME, D as TracesIngestRequestSchema, E as TraceEventSchema, O as TracesIngestResponseSchema, S as ListRubricsResponseSchema, T as RubricSchema, _ as FeedbackIngestResponseSchema, a as runRpcBatch, b as JudgeRequestSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as ErrorResponseSchema, h as listBuiltinRubrics, i as dispatchRpc, j as hashRubric, k as VersionResponseSchema, l as handleFeedbackIngest, m as getBuiltinRubric, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FeedbackTrajectorySchema, w as RubricDimensionSchema, x as JudgeResultSchema, y as HealthResponseSchema } from "../server-BRpadnVt.js";
+import { A as WIRE_VERSION, C as RUBRIC_VERSION_SCHEME, D as TracesIngestRequestSchema, E as TraceEventSchema, O as TracesIngestResponseSchema, S as ListRubricsResponseSchema, T as RubricSchema, _ as FeedbackIngestResponseSchema, a as runRpcBatch, b as JudgeRequestSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as ErrorResponseSchema, h as listBuiltinRubrics, i as dispatchRpc, j as hashRubric, k as VersionResponseSchema, l as handleFeedbackIngest, m as getBuiltinRubric, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FeedbackTrajectorySchema, w as RubricDimensionSchema, x as JudgeResultSchema, y as HealthResponseSchema } from "../server-DbcC7xMl.js";
 export { ErrorResponseSchema, FeedbackIngestResponseSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RUBRIC_VERSION_SCHEME, RubricDimensionSchema, RubricSchema, TraceEventSchema, TracesIngestRequestSchema, TracesIngestResponseSchema, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };

package/docs/campaign-proposers.md

@@ -127,6 +127,9 @@ Pass `context.evaluate` to the optimizer so every candidate is executed and scor
 Unknown case IDs and calls beyond `maxEvaluations` are rejected.
 
 Optimizer-owned model or service calls must use `context.cost.runPaidCall()`.
+Admission derives unresolved calls, reserved amounts, conservative settled spend, and maximum breaches in one record-order pass without constructing reporting summaries.
+Unknown settled costs retain any reserved maximum in the admission total, and unresolved pending calls block new paid work.
+
 The example below assumes the upstream package enforces `maxCostUsd` for the complete run and returns aggregate usage.
 If the package exposes a model callback instead, wrap each model call separately with the same cost ledger and phase.
 

package/docs/concepts.md

@@ -418,6 +418,7 @@ release decision.
 - **Need the feature map?** Read [feature-guide.md](./feature-guide.md) for integration patterns and operational limits.
 - **Scoring a string from another language?** Read [wire-protocol.md](./wire-protocol.md) for the HTTP/RPC interface.
 - **Diagnosing failures across a batch of runs?** Read [trace-analysis.md](./trace-analysis.md) for the recursive DSPy-RLM analyst and the public benchmark it's calibrated against.
+- **Stating what a finding holds for?** Read [finding-layers.md](./finding-layers.md) for layers, scope, lineage, promotion and the findings ledger.
 - **Building a driver and worker loop?** Read [control-runtime.md](./control-runtime.md) for coding, browser, computer-use, and research patterns.
 - **Turning review feedback into reusable data?** Read [feedback-trajectories.md](./feedback-trajectories.md) for dataset, optimization, and preference-memory examples.
 - **Building a code-generator eval?** → Start with `BuilderSession`, `SandboxHarness`, and `MultiLayerVerifier`.

package/docs/finding-layers.md

@@ -0,0 +1,69 @@
+# Finding layers
+
+Every analyst finding can say what it is about and what it was measured on.
+A claim measured on 4 runs of one play stays a play-level result until independent evidence lifts it.
+
+Source of truth: `src/analyst/finding-scope.ts`, `domain-taxonomy.ts`, `promote.ts`, `findings-ledger.ts`, `team-shape.ts`, `failure-modes.ts` and `rollup.ts`, all exported from `@tangle-network/agent-eval/analyst`.
+
+## The ladder
+
+| Layer | A claim about |
+| --- | --- |
+| `event`, `turn` | One step of one agent |
+| `agent` | One agent across its work |
+| `team` | How a supervision tree was organized |
+| `run` | One run |
+| `play` | Runs of one play |
+| `problem` | Plays of one problem (discovery-lab's theatre) |
+| `domain` | Problems under one domain node, at any depth |
+| `lab` | Everything |
+| `meta` | The instrument itself: a judge, a ruler, an analyst |
+
+## Schema 1.1.0
+
+AnalystFinding 1.1.0 adds `layer`, `scope`, `method`, `measure`, `confounders`, `valid_for`, `claim_id` and `evidence_units`.
+All are optional on the type, and `makeFinding` writes 1.1.0 only when one is set, so existing writers and stored 1.0.0 findings are unchanged.
+`parseAnalystFinding` reads both versions with one schema:
+
+- A 1.0.0 finding may not carry 1.1.0 fields; it reads as layer and n `unknown`.
+- A 1.1.0 finding needs `layer`, `scope` and `method`.
+- With `evidence_units`, `scope.n` and `scope.population` must match the units, and no unit may sit above the finding's layer.
+
+`readFindingScope` labels a finding `anecdote` when n < 2, `uncalibrated` when it was judged without calibration, `lineage-unknown` when a unit's lineage was not recorded, and `unscoped` for 1.0.0.
+
+`scope.population` stores resolved unit ids, never a query: `n`, `evidence_units` and promotion's lineage check compare against those ids, and a query re-run later can select a different set. Select a population with `queryFindings` and store the ids it returned.
+
+## Lineage
+
+An evidence unit's `derived_from` names the unit it inherited state from, `null` records an independent start, and an absent field records lineage nobody captured.
+Units are grouped by lineage root.
+Unknown lineage shares one root, so it can never count as independent support.
+
+## Taxonomy and promotion
+
+`defineDomainTaxonomy` builds one versioned tree of domain nodes; `attachToTaxonomy` hangs a problem on one primary domain path plus tags, a play on a problem, and a run on a play.
+Everything sits under the implicit `lab` root.
+
+`promote(findings, taxonomy, { k })` is the only way a claim moves up:
+
+1. A finding sits at the lowest common ancestor of its population. That node's layer must equal the finding's layer, so a lab-level claim measured on one play is refused, not lifted.
+2. Siblings with the same `claim_id` are grouped under their parent.
+3. Only children with `measure.interval` vote, on the same measure and unit, and their intervals must share a point.
+4. Children whose units share a lineage root count once. At least `k` independent children (default 2) are required.
+5. A lifted finding cites its children as `finding://<finding_id>`; the rest are returned as untested above.
+
+Event, turn, agent, team and meta findings are never placed on the ladder.
+
+## Ledger
+
+`openFindingsLedger` stores findings in the ledger-core journal: canonical, hash-chained, fsynced, pinned to a trusted head, and validated by the finding schema on write and read.
+`read()` returns the rows and their Merkle root.
+`queryFindings` filters by layer, subject, analyst, run, claim and domain-path prefix.
+`diffFindingsOverTime` runs `diffFindings` between consecutive runs in ledger order.
+`FindingsStore` remains the unchained JSONL store for its existing consumers.
+
+## Analysts
+
+- `team-shape` (computed, `team`) reads a Runtime spawn journal and coordination log: `teamShapeInputFromSources` takes them from `readRuntimeSupervisorRun`, and the same parser reads the structure-only reductions `extract.py` writes. E (command) edges come from the id path (`R:s1:s0` is a child of `R:s1`), G (governance) edges from the journal holding each `settled` row plus each delivered steer's sender, and C (communication) edges from coordination rows naming a receiver, sent by `from`/`by` or else the log owner's digest. Classes, version 1, checked in order: single, governed swarm, fleet, partition, `hive depth N`, star with sub-leads, flat star (`root integrates`, `root does not integrate` or `integration unknown`, from the caller's optional `integrations`). The 50% and 20% thresholds are provisional and carried in `method.version`. Every class check is reported as yes, no or `not observable from this record`; an owner digest is not an agent id, so lateral C and steer governance are usually not observable, and the record never reads them as absent. The four recorded Magnetar runs under `tests/fixtures/team-shape`, with the lead's gold labels, are the acceptance fixtures.
+- `failure-modes` (judged, `agent`, `team` or `run`) asks fixed-choice questions through `systemOneAnalyst`: a MAST-adapted failure mode, delegation-brief completeness and steer handling. `createFailureModesAnalyst` refuses a rubric whose recorded calibration κ is below `FAILURE_MODES_MIN_KAPPA` (0.6). Calibration is a live step after release: `loadFailureModeGold` reads the public AgentRx label file through `loadPublicBenchmarkRows` (the file `analyst-benchmark --dataset agentrx --labels` takes) plus the caller's gold file, the judge labels the same items, and `calibrateFailureModes` scores it. Disco runs that on the Router and commits the receipt; the AgentRx file is not stored in this repository.
+- `rollup` (computed) pools run findings per play with a lineage-clustered bootstrap, then lets `promote` decide what climbs. Each lifted finding gets the pooled interval over every run beneath it and its observation and cluster counts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.215.0",
+  "version": "0.216.0",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {