@tangle-network/agent-eval 0.220.2 → 0.221.0

package/dist/types-CnWmj8NW.js.map

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

package/dist/{types-CHfn1zg5.d.ts → types-DDKfH-N6.d.ts}

@@ -1,6 +1,6 @@
 import { g as PaidCallResult, i as CostChannel, l as CostLedgerSummary, o as CostLedgerHandle, r as CostBreakdown, u as CostProvenance, y as RunPaidCallInput } from "./cost-ledger-C1W3ICmP.js";
 import { d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-C3awiXPf.js";
-import { v as ProposalFinding } from "./types-8yQzNm8u.js";
+import { v as ProposalFinding } from "./types-DGImvHIr.js";
 import { j as LlmCallMetadata } from "./types-eMhdacVp.js";
 import { t as SeriesDistribution } from "./descriptive-B2iPaT9J.js";
 import { A as SearchLedgerHash, F as SearchNodeRegisteredEvent, G as SearchSplit, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, U as SearchReservation, Z as SearchTask, b as SearchClosedEvent, d as SearchCellCancelledEvent, i as SearchArtifactRef, l as SearchCandidateSurface, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, w as SearchEdgeRecordedEvent, z as SearchOperationRecordedEvent } from "./search-ledger-types-p2xKfiDJ.js";
@@ -1017,4 +1017,4 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
 }
 //#endregion
 export { SearchCompletion as $, LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, SearchProposerView as G, SurfaceProposer as H, ProposedCandidate as I, searchProposerView as J, SearchSummaryOptions as K, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, SearchCell as Q, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, SearchStateView as X, SearchState as Y, searchUnitScores as Z, GateDecision as _, CampaignResult as a, SearchUnitScore as at, GenerationRecord as b, CampaignTraceWriter as c, searchTaskSetDigest as ct, DispatchContext as d, SearchDecisionRecord as et, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchSpend as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, GateCheckStatus as m, CampaignArtifactWriter as n, SearchOperation as nt, CampaignScenarioIdentity as o, searchCellId as ot, Gate as p, renderSearchSummary as q, CampaignCellResult as r, SearchScoredCell as rt, CampaignTokenUsage as s, searchNodeId as st, CampaignAggregates as t, SearchNode as tt, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
-//# sourceMappingURL=types-CHfn1zg5.d.ts.map
+//# sourceMappingURL=types-DDKfH-N6.d.ts.map

package/dist/{types-CHfn1zg5.d.ts.map → types-DDKfH-N6.d.ts.map}

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

package/dist/{types-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.