@tangle-network/agent-eval 0.220.1 → 0.221.0

package/dist/{types-8yQzNm8u.d.ts → types-DGImvHIr.d.ts}

@@ -287,6 +287,79 @@ 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-composition.d.ts
+/** What was deliberately changed; this is separate from a finding's event-to-meta scope. */
+declare const TREATMENT_LAYERS: readonly ['Task', 'Model', 'Budget', 'Team', 'Roles', 'Tools', 'Memory', 'Process', 'Oversight'];
+type TreatmentLayer = (typeof TREATMENT_LAYERS)[number];
+declare const findingTreatmentSchema: z.ZodObject<{
+  id: z.ZodString;
+  definition_digest: z.ZodString;
+  definition_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>>;
+  layers: z.ZodArray<z.ZodEnum<{
+    Budget: "Budget";
+    Memory: "Memory";
+    Model: "Model";
+    Oversight: "Oversight";
+    Process: "Process";
+    Roles: "Roles";
+    Task: "Task";
+    Team: "Team";
+    Tools: "Tools";
+  }>>;
+}, z.core.$strict>;
+/** Required nullable values distinguish an unavailable observation from observed absence. */
+declare const findingConditionsSchema: z.ZodObject<{
+  id: z.ZodString;
+  population: z.ZodArray<z.ZodString>;
+  observed_at: 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>>;
+  runtime_version: z.ZodNullable<z.ZodString>;
+  lab_commit: z.ZodNullable<z.ZodString>;
+  model_version: z.ZodNullable<z.ZodString>;
+  provider_version: z.ZodNullable<z.ZodString>;
+  seat: z.ZodNullable<z.ZodString>;
+  host_load: z.ZodNullable<z.ZodNumber>;
+  started_at: z.ZodNullable<z.ZodString>;
+  operator_steers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodNullable<z.ZodString>;
+    planned: z.ZodNullable<z.ZodBoolean>;
+    evidence_ref: 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>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type FindingTreatment = z.infer<typeof findingTreatmentSchema>;
+type FindingConditions = z.infer<typeof findingConditionsSchema>;
+//#endregion
 //#region src/analyst/finding-scope.d.ts
 /**
  * The layer ladder, lowest first. `problem` is what discovery-lab calls a
@@ -444,6 +517,71 @@ declare const ProposalFindingSchema: z.ZodObject<{
     }>;
     derived_from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   }, z.core.$strict>>>;
+  treatment: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    definition_digest: z.ZodString;
+    definition_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>>;
+    layers: z.ZodArray<z.ZodEnum<{
+      Budget: "Budget";
+      Memory: "Memory";
+      Model: "Model";
+      Oversight: "Oversight";
+      Process: "Process";
+      Roles: "Roles";
+      Task: "Task";
+      Team: "Team";
+      Tools: "Tools";
+    }>>;
+  }, z.core.$strict>>>;
+  conditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    population: z.ZodArray<z.ZodString>;
+    observed_at: 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>>;
+    runtime_version: z.ZodNullable<z.ZodString>;
+    lab_commit: z.ZodNullable<z.ZodString>;
+    model_version: z.ZodNullable<z.ZodString>;
+    provider_version: z.ZodNullable<z.ZodString>;
+    seat: z.ZodNullable<z.ZodString>;
+    host_load: z.ZodNullable<z.ZodNumber>;
+    started_at: z.ZodNullable<z.ZodString>;
+    operator_steers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      at: z.ZodNullable<z.ZodString>;
+      planned: z.ZodNullable<z.ZodBoolean>;
+      evidence_ref: 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>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>>>;
   proposal_origin: z.ZodEnum<{
     production: "production";
     search: "search";
@@ -497,7 +635,7 @@ declare function independentUnitCount(units: ReadonlyArray<FindingEvidenceUnit>)
  *
  * 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
+ * `evidence_units`, with optional `treatment` and `conditions` composition. 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.
  */
@@ -561,6 +699,10 @@ interface AnalystFinding {
    * `scope.population` must match them and no unit may sit above `layer`.
    */
   evidence_units?: FindingEvidenceUnit[];
+  /** Deliberately assigned bundles; every bundle may touch several treatment layers. */
+  treatment?: FindingTreatment[];
+  /** Observed condition snapshots with population and observation-time provenance. */
+  conditions?: FindingConditions[];
 }
 /** 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'];
@@ -767,7 +909,9 @@ interface AnalystUsageReceipt {
 }
 /**
  * Compute the stable finding_id from the identity-defining fields.
- * Default implementation hashes {analyst_id, area, subject, normalized claim}.
+ * Legacy identity hashes {analyst_id, area, subject, normalized claim}. Supplied
+ * composition adds normalized treatment/fixed-condition identity; covariate provenance
+ * remains on the record without making every observation time a different claim.
  * Analysts that emit findings whose claim text varies per run (timestamps,
  * counts) SHOULD either: (a) pass an explicit `id_basis` to fix the hash,
  * or (b) move the variable part into `rationale`/`metadata` and keep the
@@ -780,6 +924,8 @@ declare function computeFindingId(input: {
   claim: string;
   /** Override the claim for hashing — use when the displayed claim has run-specific bits. */
   id_basis?: string;
+  treatment?: FindingTreatment[];
+  conditions?: FindingConditions[];
 }): string;
 /**
  * Convenience factory: produce a fully-formed AnalystFinding with the
@@ -861,5 +1007,5 @@ type AnalystRunEvent = {
   result: AnalystRunResult;
 };
 //#endregion
-export { TraceAnalystByteBudgets as $, FindingReaderLabel as A, ReadSpanSourceInput as B, FINDING_LAYERS as C, FindingMeasure as D, FindingLayer as E, lineageRoots as F, TraceAnalysisStoreContext as G, SpanSourceReader as H, parseAnalystFinding as I, ErrorCluster as J, DEFAULT_TRACE_ANALYST_BUDGETS as K, readFindingScope as L, FindingScopeReading as M, ProposalFindingSchema as N, FindingMethod as O, independentUnitCount as P, SpanMatchRecord as Q, createBoundedTraceAnalysisStore as R, makeProposalFinding as S, FindingEvidenceUnit as T, TRACE_ANALYSIS_LIMITS as U, ReadSpanSourceResult as V, TraceAnalysisStore as W, SearchSpanResult as X, QueryTracesPage as Y, SearchTraceResult as Z, ExecutionProbeRequest as _, AnalystFindingSchemaVersion as a, ViewSpansResult as at, computeFindingId as b, AnalystRunEvent as c, AnalystRunSummary as d, TraceAnalystFilters as et, AnalystSeverity as f, ExecutionProbeOutcome as g, ExecutionProbe as h, AnalystFinding as i, TraceAnalystTraceSummary as it, FindingScope as j, FindingParseOutcome as k, AnalystRunInputs as l, EvidenceRef as m, AnalystContext as n, TraceAnalystSpanKind as nt, AnalystInputKind as o, ViewTraceOversized as ot, AnalystUsageReceipt as p, DatasetOverview as q, AnalystCost as r, TraceAnalystSpanStatus as rt, AnalystRequirements as s, ViewTraceResult as st, Analyst as t, TraceAnalystSpan as tt, AnalystRunResult as u, ProposalFinding as v, FindingCalibration as w, makeFinding as x, ProposalFindingOrigin as y, BoundedTraceAnalysisStoreOptions as z };
-//# sourceMappingURL=types-8yQzNm8u.d.ts.map
+export { QueryTracesPage as $, FindingReaderLabel as A, TREATMENT_LAYERS as B, FINDING_LAYERS as C, FindingMeasure as D, FindingLayer as E, lineageRoots as F, ReadSpanSourceResult as G, createBoundedTraceAnalysisStore as H, parseAnalystFinding as I, TraceAnalysisStore as J, SpanSourceReader as K, readFindingScope as L, FindingScopeReading as M, ProposalFindingSchema as N, FindingMethod as O, independentUnitCount as P, ErrorCluster as Q, FindingConditions as R, makeProposalFinding as S, FindingEvidenceUnit as T, BoundedTraceAnalysisStoreOptions as U, TreatmentLayer as V, ReadSpanSourceInput as W, DEFAULT_TRACE_ANALYST_BUDGETS as X, TraceAnalysisStoreContext as Y, DatasetOverview as Z, ExecutionProbeRequest as _, AnalystFindingSchemaVersion as a, TraceAnalystSpan as at, computeFindingId as b, AnalystRunEvent as c, TraceAnalystTraceSummary as ct, AnalystRunSummary as d, ViewTraceResult as dt, SearchSpanResult as et, AnalystSeverity as f, ExecutionProbeOutcome as g, ExecutionProbe as h, AnalystFinding as i, TraceAnalystFilters as it, FindingScope as j, FindingParseOutcome as k, AnalystRunInputs as l, ViewSpansResult as lt, EvidenceRef as m, AnalystContext as n, SpanMatchRecord as nt, AnalystInputKind as o, TraceAnalystSpanKind as ot, AnalystUsageReceipt as p, TRACE_ANALYSIS_LIMITS as q, AnalystCost as r, TraceAnalystByteBudgets as rt, AnalystRequirements as s, TraceAnalystSpanStatus as st, Analyst as t, SearchTraceResult as tt, AnalystRunResult as u, ViewTraceOversized as ut, ProposalFinding as v, FindingCalibration as w, makeFinding as x, ProposalFindingOrigin as y, FindingTreatment as z };
+//# sourceMappingURL=types-DGImvHIr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-DGImvHIr.d.ts","names":[],"sources":["../src/trace-analyst/types.ts","../src/trace-analyst/store-contract.ts","../src/trace-analyst/store-boundary.ts","../src/analyst/finding-composition.ts","../src/analyst/finding-scope.ts","../src/analyst/types.ts"],"mappings":"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"}

package/dist/{types-D8GXK9Z5.d.ts → types-IERw_HxR.d.ts}

@@ -1,5 +1,5 @@
 import { c as RunSplitTag } from "./run-record-C3awiXPf.js";
-import { R as Scenario, d as DispatchContext } from "./types-CHfn1zg5.js";
+import { R as Scenario, d as DispatchContext } from "./types-DDKfH-N6.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-D8GXK9Z5.d.ts.map
+//# sourceMappingURL=types-IERw_HxR.d.ts.map

package/dist/{types-D8GXK9Z5.d.ts.map → types-IERw_HxR.d.ts.map}

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

@@ -1,7 +1,7 @@
 import { m as CustomTokenPricing, o as CostLedgerHandle } from "../cost-ledger-C1W3ICmP.js";
 import { x as ChatClient } from "../types-eMhdacVp.js";
 import { s as TraceStore } from "../store-B3nWRy3B.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DhB9WzYg.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-BZhVCWuz.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";

package/docs/behavioral-trace-questions.md

@@ -0,0 +1,99 @@
+# Bounded behavioral trace questions
+
+`behavioralAnalyst` on `@tangle-network/agent-eval/analyst` retains its call-free arithmetic
+pass. Its optional `traceQuestions` field adds explicitly selected event, turn and agent
+windows. Callers supply a model, evaluator, its explicit `ExactExecutionComponentIdentity`, the existing findings ledger and a named,
+versioned window extraction policy. The option refuses excess windows or bytes; it never
+silently samples or truncates input. The default limits and fixed questions live in
+`src/analyst/behavioral-trace-validation.ts` and `behavioral-trace-questions.ts`.
+
+Each window includes a nonempty bounded `events` list of `{ id, content, evidenceRefs }`.
+IDs are unique within the window; `unresolved` is reserved. `content` is the sanitized event
+text or JSON actually available to the judge. References must resolve retained immutable
+source artifacts; the caller owns their retention and faithful extraction. The stored content
+digest binds the supplied sanitized event, but does not certify an external artifact's availability.
+The window byte cap covers these events as well as the rest of the window. `maxRequestBytes`
+also bounds the canonical native body, including all questions and retained mapping, before
+any dispatch. Neither cap truncates input.
+
+Each window names a source trace in the analyzed store, a subject, source references,
+immutable timestamps and capture limitations. The caller owns extracting and sanitizing
+the actual source content and resolving the references; membership in the trace store
+does not certify that an arbitrary supplied excerpt faithfully represents that trace.
+Native capture gaps stay explicit. Root-stream attempt numbers do not establish turns.
+Selection policy settings belong in `windowPolicy.config`, so changing extraction changes
+calibration identity. Never include labels, rewards, expected outputs or test answers in
+`state`; independent gold travels only to the calibration reader.
+
+The fixed battery has nine observations per window, including negative, unsure and
+unavailable answers. Eight semantic questions and eight ancillary supporting-event choices share one native
+SystemOne request via `decisionPoint`, following DomainMatch's finite source-choice pattern.
+Each support choice has the supplied event IDs plus an explicit `unresolved` option. It is
+an independent classification of relevant evidence, not a generated rationale, causal grounding,
+or a guarantee that another answer is justified. Unresolved support does not relabel a semantic
+Yes/No or change its existing alarm eligibility. Ancillary policies are explicitly record-only;
+they have no independent routing authority or calibration certificate.
+
+The exact ordered `sourceMap` (window and trace IDs, event IDs, sanitized-content digests and
+references) and its digest live in the persisted decision definition's support-question
+instructions of `evidence.unverified-completion`; other support questions reference that
+map owner and digest rather than copying the map. Replay reconstructs that map from the durable record and returns it in each
+observation's `metadata.behavioral_trace_question.support`, including selected IDs, unresolved,
+unavailable and probabilities. Source event content remains in the supplied state, so retain
+the referenced artifacts to inspect the selected source. State/input digests alone are not
+source retention. Changing IDs, content, references or map order under the same invocation
+conflicts before dispatch. The versioned request contract invalidates old calibration certificates.
+
+Exact tool repetition is computed from tool names and canonical arguments
+on distinct physical attempt IDs. Each attempt also requires an explicit `eventId` in the
+window. Computed positive support returns the matching attempts' source event IDs; a computed
+absence or incomplete capture has unresolved support rather than an invented event. Duplicate capture rows are deduplicated; conflicting
+payloads for one attempt are refused. An incomplete tool capture can establish observed
+repetition, but cannot establish its absence. Repetition alone makes no claim about waste.
+The computed observation has no fabricated model identity, probabilities or paid receipt.
+
+Decision intents, native records and question observations share the supplied findings
+journal. A repeated analysis with the same run, explicit durable `analysisId`, configuration and windows
+replays without another inference. Changing those inputs under the same invocation is a
+conflict; use a new `analysisId` for an intentional new analysis. Observation times come from the
+source window, so replays do not conflict merely because the wall clock advanced.
+A concurrent reader of an unresolved intent cannot finalize observations. Registry logging correlation IDs may change across restarts without spending again.
+Cancellation and deadlines suppress delivery while retaining paid work and durable records.
+The existing analyst adapter supplies one shared budget and forwards every provider receipt;
+missing usage remains unknown. A replay reports zero new physical calls, not a free model
+receipt for a previous call.
+
+## Independent calibration and alarms
+
+`calibrateBehavioralTraceQuestions` joins independent `{questionId, windowId, label, source}`
+gold rows to the emitted findings. It returns all nine per-question rows with exact n,
+source counts, missing/unsure labels, missing predictions, abstentions, confusion counts,
+agreement and Cohen's kappa from the existing statistics owner. Its `disagreements` list
+shows every wrong, unsure or missing prediction with the selected event IDs/unresolved and
+complete scoped map; historical findings without captured support return null. It never
+invents pointers for old decisions. Semantic question digests stay independent of the event-ID
+set, so this reader aggregates multiple windows/maps. Generic decision-point `reliability()`
+instead groups the exact definition, which includes the map and can yield one-map samples;
+that output is not a cross-map probability calibration or threshold-tuning claim. Gold unsure/null labels
+are exclusions, never No; missing predictions remain disagreements. Empty and degenerate
+samples have null kappa. A missing prediction or one-class gold set cannot issue a routing
+certificate. The minimum kappa is owned by `DECISION_POINT_MIN_KAPPA` on `/systemone`.
+
+The evaluator identity covers transport, normalization, receipt interpretation, pricing and spending policy; it must change when those semantics change. It is captured once and bound in exact execution and calibration identities.
+
+Certificates bind the exact question, option order, implementation version, evaluator identity, layer,
+window policy, requested model and served model. Computed certificates bind the extractor
+and policy with a null served model. Store their validation evidence in observation metadata;
+`method.calibration` remains exclusive to judged findings. A label file is evidence only
+for its declared scope: AgentRx root-cause categories are not labels for every question,
+turn or agent, and an absent failure category is not a negative label.
+
+Install returned certificates explicitly in `traceQuestions.calibrations` by layer and
+question. Uncalibrated, mismatched, uncertain or failed judgments cannot alarm. A qualifying
+positive recommends only `coordinator-alarm` for reversible investigation. This surface
+has no pass/fail acceptance authority and performs no coordinator action itself.
+Integration fixture labels test wiring only; they are never scientific calibration.
+
+Before enabling real alarms, retain independent human/compatible AgentRx labels and the
+per-question report. Diagnostic development anchors are not a sealed holdout or prevalence
+estimate. Keep unseen calibration evidence for judging a changed rubric or extraction policy.

package/docs/experiment.md

@@ -302,3 +302,30 @@ separation or equivalence. Their numeric point estimates remain `0` for compatib
 this is a placeholder, not a measured zero. Retain the trial count with Wilson
 results, and use the returned `n` for paired results, before displaying an estimate.
 Nonempty-sample estimators retain their existing semantics and limitations.
+
+### As-assigned and as-formed arm populations
+
+Supply `assignments` to the existing `comparePairedArms(rows, options)` reader when the
+expected seed population is known. Each roster entry names `arm`, `pairKey`, optional
+`repKey` and optional treatment array. Build this roster independently of completed run
+records; a roster inferred from successful runs cannot reveal missing assignments.
+
+Observation rows retain `pass` and `metrics` independently of their optional
+`formation: { formed, reason? }` verdict. The execution owner defines formation; this
+reader consumes its boolean or explicit null. Null or absent outcomes/metrics are unknown,
+while false and zero are measurements. A team-not-formed record can still have an observed
+acceptance result and cost, and those stay in the as-assigned summary.
+
+With a roster, `armPopulations` reports each arm's assignments, missing observations,
+formed/not-formed/unknown counts and both `asAssigned` and `asFormed` summaries. Only an
+explicit true formation verdict enters as-formed. Each summary reports all its units,
+passes, failures, missing outcomes and metric-specific observed/missing denominators.
+`passRate` is null when any outcome is missing; metric sums/means are null when no reading
+exists. This prevents an absent result from becoming a measured failure or zero cost.
+
+The same left join supplies matched-pair statistics: missing seeds carry identity-only
+placeholder rows, so pair coverage includes declared seed identities while correctness
+and metric statistics still require actual observations on both sides. Duplicate
+assignments, results outside the roster and corrupt metrics fail loudly. Without a roster,
+the existing observed-pair behavior remains and `armPopulations` is absent: the assignment
+population is unknown, never inferred from completed rows.

package/docs/finding-layers.md

@@ -65,5 +65,58 @@ Event, turn, agent, team and meta findings are never placed on the ladder.
 ## 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.
+- `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 the source-owned `FAILURE_MODES_MIN_KAPPA`. `loadFailureModeGold` reads public AgentRx annotations through `loadPublicBenchmarkRows` plus a caller's gold file; `calibrateFailureModes` scores the judge's labels against that gold. The full AgentRx dataset is external; [recorded boundary fixtures](../tests/fixtures/agentrx-actor-boundary/README.md) retain only the cases needed to check admission and historical receipt preservation.
 - `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.
+
+### Failure-mode gold admission
+
+[`loadFailureModeGold`](../src/analyst/failure-modes.ts) owns AgentRx's projection onto agent/team root-cause labels. It reads the annotated root failure, including its actor; it does not infer an assistant fault from a user's behavior. User-origin underspecification has no counterpart in the agent's `fail-to-ask-for-clarification` label. The source owns the recognized agent roles; unfamiliar or missing actors cannot silently become agents.
+
+A successful load reports `eligibility`, `agentRxMapping`, eligible `gold`, and `unmapped` rows. The existing `unmapped` field retains each source id/category and adds its root failure id, step, actor, and a typed reason: `unsupported-root-actor`, `unknown-root-actor`, or `category-without-counterpart`. `agentRxMapping` records the mapping version and `agent-or-team-root-cause` target, or is null for caller-only gold. Consumers must carry that provenance and the actual exclusion reasons into a **new** calibration receipt, rather than treating every exclusion as an unmapped category.
+
+An all-excluded, otherwise valid AgentRx file returns `eligibility: 'unknown'`, no gold labels, and the exclusion evidence. That is a parsed source without calibration evidence, not a successful empty calibration or a measured absence of failures. Invalid input still returns a failed outcome. Caller-supplied gold remains the caller's assertion and is not certified as independent by this loader.
+
+Caller gold ids must be disjoint from **all** AgentRx source ids, including excluded rows. A caller cannot reintroduce an excluded source id as eligible gold; overlapping ids are invalid. Caller ids with surrounding whitespace are invalid, so whitespace cannot disguise an overlapping source id. Valid caller ids are preserved exactly. Caller-only gold and disjoint caller ids remain supported.
+
+Existing receipt rows, source hashes, labels and verdicts are historical evidence. Loading a new mapping never regrades, relabels or filters a stored receipt. A new mapping, selection policy, question or input representation requires a new calibration configuration with its rule fixed before judging.
+
+### Calibration and runtime contract
+
+The maintained [`FAILURE_MODES_QUESTIONS`](../src/analyst/failure-modes.ts) object is the one question/criteria owner. `createFailureModesAnalyst` currently sends all its questions; calibration of `failure_mode` alone does not qualify the other outputs.
+
+| Output | Target and required evidence |
+| --- | --- |
+| `failure_mode` | The causal agent/team failure explaining the observed shortfall, rather than an arbitrary downstream symptom or a user-origin annotation. AgentRx gold targets the annotated root. Inputs need the applicable task/policy, observed actions and tool results, actor identity, and an independently established outcome where available. A user ambiguity alone does not establish an agent's failure to clarify. |
+| `delegation_brief` | The actual delivered briefs and whether they include the goal, constraints, expected output and check; not an inferred brief from child creation. |
+| `steer_handling` | The delivered correction and the agent's subsequent behavior; lack of a correction record is not proof that none arrived. |
+
+Before the next calibration, the consuming owner must use this full shared question object on the same declared target and evidence representation as runtime, and report independent gold, paired counts and reliability **per output**. Unknown or missing required observations stay outside the judge's measured population with an explicit reason. `none`, `no-delegation` and `no-steer` are observed classifications, not substitutes for unavailable evidence. Merely requesting all questions does not create independent labels for them.
+
+This is the required consumer migration, not a claim that it has shipped: Lab's existing calibration asks only `failure_mode` over public trajectories, while its runtime reads coordination/spawn logs and asks all outputs. Lab owns reconciling those inputs and recording the target, mapping version, selection/exclusions, questions, model/served identity and source hashes in its next receipt. An applicable task/policy may be supplied as observation context; expected benchmark actions/outputs, root annotations, category rationales and other gold must remain outside the judged state. No old receipt is promoted by this source correction.
+
+## Treatment and recorded conditions
+
+Optional `treatment` and `conditions` arrays on a 1.1.0 finding preserve run composition.
+A treatment is a named bundle with an immutable definition digest, source references and
+all applicable `TREATMENT_LAYERS` tags. These input tags are separate from `FindingLayer`,
+which says how far a claim holds. Arms and findings may carry several bundles.
+
+Each conditions snapshot names its measured population, observation time and evidence.
+Runtime/Lab/model/provider versions, seat, host load, start time and operator steers are
+explicit nullable readings. Null means unavailable; an empty observed steer list means
+none were observed. A snapshot ID identifies an immutable record; rollup and promotion reject conflicting content for the same ID anywhere in their input, before grouping. Capture conditions from
+execution evidence; do not ask a judge to invent them or infer formation from an assignment.
+The public types are on `@tangle-network/agent-eval/analyst`.
+
+The finding identity includes the treatment definitions and fixed environment conditions
+when composition is supplied. The finding factory normalizes unordered composition arrays, so reordering bundles, layer tags or condition snapshots preserves both identity and ledger replay payload.
+Absent legacy composition and explicitly empty arrays remain distinguishable. Existing
+findings without composition retain their old identity and remain readable.
+
+`rollupFindings` and `promote` use the same composition identity for grouping and output
+IDs, including the underlying-run re-pooling after promotion. Different bundles, fixed
+versions, seats or unplanned/unknown steering states do not silently pool. Varying load,
+observation time and source references retain their population-linked provenance without
+splitting an otherwise matching group. Matching recorded conditions do not establish
+that every possible confounder was observed; experiment owners still enforce declared
+factors and interleaving before execution.

package/docs/rollout.md

@@ -54,6 +54,15 @@ Where each invariant lives:
 
 ## Runtime capture receipts
 
+Runtime spawn journals accept historical `event` envelopes and atomic `events` envelopes.
+`readRuntimeSupervisorRun()` and the direct `parseSupervisorTree()` analyzer expand each group in order.
+Every group member must be an object with a non-empty event kind; a malformed group contributes no events.
+The file reader throws on corruption, while the direct analyzer counts the whole group as one invalid input row.
+Empty groups are valid no-ops; the direct analyzer counts them under `journalIgnoredRowsByKind.events`.
+`journalRows` counts non-empty input lines, while event counters count each member of a valid group.
+Grouped resource evidence names its member as `journal.rows[N].events[I]`.
+Flat analyzer journals remain supported, and unknown usage flags are preserved.
+
 `readRuntimeSupervisorRun()` reads output references in journal order.
 It reads retained execution results and terminal outputs through the same projector.
 It projects duplicate references to the same node and address once.

package/docs/systemone.md

@@ -96,6 +96,26 @@ probabilities are not calibrated domain confidence, and a result never authorize
 sending, deletion, or another effect. Re-assessing the same prepared input and retained answer is
 an offline replay, not new inference.
 
+## Rationale and evidence limits
+
+The native request and answer types in [`systemone-protocol.ts`](../src/systemone-protocol.ts)
+declare no free-form rationale, generated evidence URI, or extracted text-span field.
+Instructions asking for an explanation do not establish a supported output contract.
+Do not issue a second explanation call to fill this gap.
+
+The same request can include another named `choice` question whose criteria keys are
+caller-supplied evidence IDs, including an explicit unresolved option. DomainMatch already
+uses this pattern for source selection. The answer selects from that finite set; it does
+not establish that the selected source caused or justifies another answer. Persist the
+immutable ID-to-source mapping with the decision (as behavioral trace definitions do), or in
+retained evidence referenced by the invocation's `evidenceRefs`.
+The journal stores state/input digests, so a mapping held only in `state` cannot support
+later inspection. Grounding and calibration require independent checks.
+
+Native response extensions may survive parsing into the evaluator's returned raw value.
+That does not promise the provider generates them or that downstream records retain them.
+The declared protocol and each consumer's persistence schema determine what survives.
+
 ## Providers, rounding and confidence
 
 The wire format is the same for every provider; how each reports its numbers is not. A
@@ -236,3 +256,90 @@ rubric lives in `examples/`, not the generic implementation, and is not a defaul
 Protocol: https://docs.typesafe.ai/api
 Clef: https://developers.cloudflare.com/workers-ai/models/clef/
 SDK (optional builders): https://github.com/typesafe-ai/typesafe-sdk-js
+
+## Decision points
+
+`decisionPoint` from `/systemone` adds durable routing to the evaluator. A point
+serves many `layers`; each invocation names its current layer and consumer.
+The same layer can use many points. Questions use typed choices; policies map
+every option to `act` (with a route), `escalate`, or `record`, with probability
+and margin thresholds per question. These are recommendations; the consumer
+performs and records the actual action. An escalation in any question takes
+precedence over `act`, which takes precedence over `record`.
+
+Use this for judgment over unstructured state only when a wrong recommendation
+is cheap and reversible and uncertainty can reach an agent or a human. It never
+grants authority to delete, deploy, merge, retire, lift a stand-down, or override
+an acceptance check. Code continues to read objective facts directly. Sample or
+trigger these calls instead of evaluating every event. Existing DomainMatch
+continues to supply its domain-specific request and assessment; this primitive
+uses the same native evaluator and answer validation, not another model adapter.
+
+A policy may drive a route only with independent labeled evidence: positive
+`gold_n`, finite Cohen κ meeting `DECISION_POINT_MIN_KAPPA` (owned in
+[`decision-point.ts`](../src/decision-point.ts)) and `evidenceRefs`.
+`decisionQuestionDigest({ id, version, model, servedModel, name, question })` binds that
+evidence to the authored question, option order and model. Changed served model
+identity, absent/stale calibration, ties and below-threshold answers escalate.
+κ measures label agreement; the joined outcome curve measures probability
+reliability. Do not describe one as proof of the other.
+
+Supply `ledger: openFindingsLedger({ path })` from `/analyst` and the existing
+`SystemOneEvaluatorOptions` as `evaluator`. `decide` accepts `runId`,
+`invocationId`, `layer`, `consumer`, `state`, `scope`, `at`, and `evidenceRefs`,
+plus the existing evaluation context for cancellation, spending and receipts.
+Inspect the typed `succeeded` result before reading its `value`.
+
+The findings ledger is the sole persistence owner. Every invocation first
+appends a 1.1.0 intent with a unique owner token. Competing callers cannot both
+infer. Completed calls record state/input/definition digests, the policy and
+calibration identity, requested/served model, probabilities, recommendation and
+receipt. Failed or cancelled evaluations record escalation with accounting when
+available. A persistence failure returns a typed error and withholds action.
+Exact `(point id, runId, invocationId)` replay reuses the original result, across
+restart; changed inputs or definitions conflict. The input includes its original
+`at`, so callers retain it. An intent without a result remains explicit and
+escalates; deliberate recovery uses a new invocation id instead of silently
+repeating a possibly paid call. The journal's normal lock/dead-owner rules apply.
+
+Decision records persist each named choice and its probabilities, so an explicit
+evidence-ID question uses the same ledger and replay path. They do not automatically
+retain arbitrary native response extensions or convert a selected ID into an `EvidenceRef`.
+The record's `reason` (for example, `uncalibrated`) is a computed policy reason, not a
+model-authored rationale; the receipt records accounting. Each additional routing question
+needs its own policy and calibration, and an uncalibrated routing question escalates the invocation.
+An explicitly `recordOnly: true` policy captures an ancillary choice without routing authority:
+all its options must use `action: 'record'`, and it cannot carry a calibration certificate.
+Its answer has `reason: 'record-only'`; provider failures still escalate. This policy does
+not bypass the calibration or thresholds of another question. Reliability lists these questions
+in `recordOnlyQuestions` and excludes them from outcome completeness and calibration curves;
+a fully labeled decision needs at least one answered routing question.
+
+`reliability()` groups the exact `definitionDigest`, including option sets and any retained
+source map. Distinct window maps therefore do not form a cross-window probability curve.
+For behavioral trace questions, use `calibrateBehavioralTraceQuestions` for semantic nominal
+agreement across maps; it binds the stable semantic question digest and reports each disagreement's
+selected event and map. A one-map result does not justify probability threshold tuning.
+
+Call `observe({ runId, invocationId, labels, at, evidenceRefs })` later to join
+independently observed option labels to a decision. This is the answer's truth,
+not whether a downstream workflow happened to succeed. Retain the original
+observation timestamp for exact replay. Conflicting labels refuse append.
+`reliability()` reads the same ledger and returns total decisions, labeled and
+missing outcomes, and per-question sample counts, empirical curves and threshold
+accuracy. A curve needs two labels; otherwise it is `null`. Threshold tables are
+development evidence for an explicit policy revision and fresh confirmation,
+not automatic tuning or activation. Failed calls remain in the denominator.
+
+Decision findings retain their measured layer and scope. The existing `/analyst`
+`promote` is the only owner for generalizing claims; it does not authorize
+routing and does not lift event/turn findings directly into run-level claims.
+
+The data model permits many-to-many associations. The only intentional
+one-to-one rules are one primary measure per hypothesis (to prevent choosing
+a winner after seeing outcomes), with any number of secondary measures, and
+one implementation per code concept (to prevent divergent owners).
+
+Decision-point construction validates the complete calibration object, including nonempty structured evidence references, before any inference. Malformed configuration throws; well-formed evidence below the calibration bar still escalates. `observe()` returns a typed `invalid` result for uncloneable, noncanonical or malformed observation data without appending an outcome. A provider identity with surrounding whitespace is rejected as a failed evaluation; its durable escalation replays and remains readable by reliability reporting.
+
+The existing behavioral analyst optionally applies bounded [trace questions](behavioral-trace-questions.md) through decision points; exact repeated tool calls stay computed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.220.1",
+  "version": "0.221.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": {