@tangle-network/agent-eval 0.150.2 → 0.161.0

package/CHANGELOG.md

@@ -4,7 +4,147 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
-## [Unreleased]
+## [0.161.0] — 2026-08-21
+
+### Added
+
+- One raw-finding wire codec for both languages (#636, supersedes #567, #579, #606). `decodeRawFindingArray(value)` (TypeScript, `/analyst`) and `decode_raw_finding_array(value)` (Python, `agent_eval_rpc.finding_codec`) decode a findings array under one set of rules and return the accepted rows plus a diagnostic per refused row — index, field path, rejection code, message. Python validates against `finding_contract.json`, which `pnpm run contract:finding` generates from the TypeScript schema (`z.toJSONSchema` plus the subject grammar as acceptance patterns) and CI checks byte-for-byte, so neither side keeps a hand-maintained copy of the other's schema. A shared corpus in `tests/fixtures/finding-codec/` runs in both CI lanes and asserts the same accepted rows and the same rejection paths and codes.
+- `FINDING_SUBJECT_PATTERNS` and `isFindingSubject()`: the subject grammar as portable acceptance patterns, proven equal to `parseFindingSubject` over every kind's valid and invalid forms. Python now enforces the subject grammar it previously ignored, so it can no longer report success for a row TypeScript rejects.
+
+### Fixed
+
+- A findings submission can no longer become a silent empty result. Measured on the previous release: a list handed to the bridge raised an unhelpful "must be a non-empty trimmed string" and discarded the completed investigation, while the Python repr of that same list parsed to zero rows and reported success. A list or mapping is now canonical-JSON encoded before it crosses the string boundary; a repr, unparseable text, or any non-array type raises with the type it received. Only an explicitly empty array is an empty result. `_SAFE_FIELD_DEFAULTS["findings_json"] = "[]"` is deleted, and an unrecoverable findings field is now reported by name instead of defaulting to an empty array.
+- The generic repair prompt no longer carries CodeTrace's "return [] if the answer reports no incorrect steps" rule, which erased valid factual findings from a generic analysis; it asks for citable claims and returns `[]` only when the answer contains none. CodeTrace keeps its own prompt. The one declared repair turn now receives the exact row defects, and a repair failure preserves both the defects and the prose answer.
+- Rejected rows travel in `runtime.rejectedFindings` from Python under the same key TypeScript already used, so a caller sees per-row diagnostics from both sides rather than a bare count from one.
+
+### Removed
+
+- `coerceToFindingRows` (no consumer outside its own test). It promoted a single object to a one-row array and turned any unrecognized value into `[]` — both widened what TypeScript accepted past what Python does, which is how one language reported findings the other dropped. `decodeRawFindingArray` replaces it and reports what it refused.
+
+---
+
+---
+
+## [0.160.0] — 2026-08-21
+
+### Removed
+
+- Every Eval-owned paid model transport (#539). Agent Eval owns comparison, scoring, and durable evidence; it no longer executes a paid model, accepts a provider URL, or holds a credential. The caller supplies a `ChatClient`, and on Agent Runtime `profileChatClient` / `profileOptimizerModelCall` are that transport, so exact `AgentProfile` identity, retries, usage, cache accounting, and interruption safety stop being optional.
+  - `createChatClient` loses its `router`, `direct-provider`, and `cli-bridge` variants. `custom`, `sandbox-sdk`, and `mock` remain, and `ChatTransport` narrows to those three.
+  - The root barrel no longer exports `callLlm`, `callLlmJson`, `LlmClient`, `LlmClientOptions`, `assertLlmRoute`, `LlmRouteRequirements`, or `probeLlm`. `assertLlmRoute` and `probeLlm` are deleted outright: the caller holds the endpoint, so the caller owns both the route check and the reachability probe. The canonical contract stays public — `LlmCallRequest`, `LlmCallResult` (including `logprobs`, `toolCalls`, `servedModel`), `LlmMessage`, `LlmUsage`, `costReceiptFromLlm`, `costReceiptFromLlmError`, `maximumChargeForLlmRequest`, `isTransientLlmError`, `stripFencedJson`.
+  - `createOpenAiCompatibleExecutionOwner` is gone from `/campaign`. Agent Runtime already owns that role with `profileOptimizerModelCall`, which executes one exact `AgentProfile` and reports profile-digest evidence; two owners for one role was the defect. `examples/_shared/openai-compatible-owner.ts` is the caller-side reference implementation, and it is example code, not a published export.
+  - `multishot/router.ts` is deleted with `routerCompletion`, `requireRouterApiKey`, and `defaultRouterBaseUrl`. `runMultishot`, `runMultishotMatrix`, and `runJudge` now require a caller-supplied `MultishotTransport`; `JudgeConfig.transport` is required and `JUDGE_MODEL` is no longer read from the environment. `MultishotToolExecutor` receives `{ transport, signal }` instead of `{ apiKey, baseUrl, signal }`, and the optional `toolTransport` names the leg the built-in delegate tools run on. `estimateRouterCost` is now `estimateMultishotCost` in `multishot/cost.ts`.
+  - `preflightModels` and `assertModelsServed` take `request: ModelEndpointRequest` instead of `baseUrl` and `apiKey`. Agent Eval asks for a `list-models` or a `probe` check and reads the `Response`, so status, the provider's own `error.message`, `budgetExhausted`, and served-model substitution stay exactly as detectable as before.
+  - `runIntentMatchJudge`, `runSemanticConceptJudge`, `handleJudge`, `dispatchRpc`, and `createApp` take `chat: ChatClient` (plus optional `pricing`) instead of `llm: LlmClientOptions`. `/v1/judge` refuses with `llm_not_configured` (503) when no transport is configured, which replaces the old route assertion.
+  - The internal OpenAI-compatible client has no default endpoint. `DEFAULT_BASE_URL = 'https://router.tangle.tools/v1'` is deleted and `baseUrl` is required, so a misconfigured caller fails loudly instead of silently billing the public router — the failure `assertLlmRoute` existed to catch, now unrepresentable.
+  - `runEvalCampaign` takes `chatFactory: (wiring: CampaignChatWiring) => ChatClient` instead of `llmOpts`, and `CampaignRunContext.chat` replaces `ctx.llmOpts`. The campaign passes each run's `rawSink` and `runId` into the factory, so a transport that binds them still satisfies `assertRunCaptured`'s raw-coverage check. The campaign fingerprint now folds a caller-declared `executionRef` where it previously folded the base URL and provider it can no longer see.
+
+### Added
+
+- `paidJsonChat` collapses the three hand-rolled copies of "reserve the priced maximum, call the transport with a stable call id, settle the receipt, parse the JSON answer" that the two judges and the wire judge endpoint each carried. A malformed answer keeps its settled receipt: the call completed and was billed, so the spend stays known rather than becoming unknown.
+- `LlmChargeBounds`: the narrow bound inputs `maximumChargeForLlmRequest` actually reads, so a caller can price a request without naming a transport options type.
+- `examples/_shared/openai-compatible-owner.ts` exposes one OpenAI-compatible endpoint two ways — `openAiCompatibleChatClient` for judges and workers, `openAiCompatibleExecutionOwner` for the optimizer surface — as the reference for what caller-owned execution looks like.
+
+### Changed
+
+- The `agent-eval` binary is the one place in the package that reads a provider credential, and it is documented as such. `agent-eval serve` / `rpc` / `rpc-batch` build their own `ChatClient` from `AGENT_EVAL_LLM_*` (or the `OPENAI_*` / `TANGLE_*` equivalents) inside `src/cli-config.ts`. Both a base URL and a key are required; a half-configured server refuses instead of calling an unintended endpoint.
+
+## [0.159.1] — 2026-08-21
+
+### Added
+
+- `pnpm check:canonical-json` (#646, part 3 of 3), wired into `verify:package`. The gate reads every function under `src/` and fails the ones that sort object keys AND serialize in the same body — the shape of a hand-rolled canonical-JSON encoder. Eleven such copies existed before this arc and disagreed on `undefined`-valued keys, `Date`, and integer-like key order, so one value hashed differently depending on which copy ran. Sorting counts through a module-local helper, so splitting the sort into `JSON.stringify(sortKeys(v))` does not evade the gate; a key-SET check that sorts and compares is not reported, because the sorted list is never iterated to build output. An explicit allowlist names the three private legacy verifiers that must keep the retired bytes, and a waiver that matches nothing fails the gate so a stale entry cannot hide a new copy. `CLAUDE.md` names `src/ledger-core/canonical.ts` as the one home.
+
+---
+
+## [0.159.0] — 2026-08-21
+
+### Changed
+
+- Durable digests name their scheme (#646, part 2 of 3). A signed `HypothesisManifest`, a `SealedExperiment`, and an `AgentProfileCell` id are each written once and verified later, possibly by a different release, so each now records the encoder that produced it and verification selects the encoder from the record. `signManifest` writes `algo: 'sha256-rfc8785'` and `sealExperiment` writes the same tag; an `AgentProfileCell` id is now `agent-profile-cell:sha256-rfc8785:<digest>`. Records written under the previous key-sorted `JSON.stringify` scheme — tagged `'sha256-content'`, carrying no `algo`, or carrying the bare `agent-profile-cell:sha256:` prefix — still verify. Each legacy encoder is private to the module that verifies with it and is unreachable from any path that writes a digest; `docs/experiment.md` records when they can be retired. An `algo` this release does not recognize is refused rather than read as valid.
+- `hashJson`, `agentProfileHash`, and the analyst-benchmark receipt digests route through `ledger-core/canonical`. Benchmark receipts are digested before they are written and re-digested when they are read back, so they digest the JSON document form: the new exported `jsonDocument()` states that rule — a JSON file cannot carry `undefined`, so an undefined-valued key is absent — while every other ambiguous value stays refused, unlike `JSON.stringify`, which turns `NaN` into `null`. Analyst-benchmark receipts need no algorithm tag: the run identity that gates every resume already pins `implementationSha256`, a digest over the implementation sources including the encoder itself, so a receipt written by another release is refused before any digest is compared.
+- `agentProfileHash` is byte-identical to the digest the previous encoder produced, and an AgentRx case definition no longer carries `undefined`-valued metadata keys — both pinned by tests.
+
+### Removed
+
+- `canonicalize` is no longer exported (root and `./experiment`). It was the key-sorting half of the retired digest scheme; `hashJson` canonicalizes internally, and a caller that needs the encoding directly uses `canonicalString` from `./ledger-core`. `manifestContentDigest` is exported in its place: the one synchronous manifest digest, selected by `algo`, that `sequentialPairedGate` now shares instead of re-implementing the rule.
+
+---
+
+## [0.158.0] — 2026-08-21
+
+### Fixed
+
+- Every result-bearing random draw is seeded (#411, criterion 2). Five byte-identical private copies of `mulberry32` lived beside the canonical one, in `meta-eval/rubric-predictive-validity.ts`, `rl/active-curriculum.ts`, `rl/adaptation-eval.ts`, `summary-report.ts`, and `promotion-gate.ts`; four fell back to `Math.random` when the caller passed no seed, so the rubric verdict, the Thompson allocation, the adaptation-curve intervals, and the reported posterior were silently non-reproducible. `meta-eval/correlation-study.ts` called `Math.random` directly inside its bootstrap and offered no seed at all. All six now route through `makeRng`, which derives the seed from the observations when the caller supplies none, so the same input reproduces the same interval; `correlationStudy` gains the `seed` option its sibling already had. `Math.random` references in `src/` fall from 19 to 10, and every remaining one produces an identifier or a retry delay that no reported number reads. The seat-by-seat audit table is in `docs/design/statistics-decisions.md`.
+- Two documentation fences imported `@tangle-network/agent-eval/../src/trace-repair`, which cannot resolve; they now import `@tangle-network/agent-eval/trace-repair`. Three fences that are not TypeScript — an object fragment, a call elided as `{ ... }`, and a method sketch — are marked `text`.
+
+### Changed
+
+- Test classification for #411 criterion 4, recorded in `docs/design/statistics-decisions.md`: the no-throw assertions that discarded a returned value now assert the value; the ones that pin a void guard's accept case are kept, because for a fail-closed gate "does not refuse a legal input" is the assertion. The five module mocks each carry a one-line justification in their file header, and the six conditional skips are tabulated with the environment variable or platform that gates them.
+
+---
+
+## [0.157.0] — 2026-08-21
+
+### Removed
+
+- 86 published value exports that no consumer binds (#411, criterion 3). Every subpath's named value exports were enumerated mechanically and checked against 31 repositories that depend on this package (each on its default branch, commits recorded in `docs/public-api.md`), this package's own CLI, wire server, examples, tests, and Markdown front doors. A symbol with no evidence in ANY channel left the barrel; 11 whose declaration nothing referenced were deleted outright, and 75 that their own module still uses lost only the `export` keyword. A symbol whose only reference is a test, a doc, a script, or a second module was kept and stays listed as `none` in the census — the census names the five blind spots that make a `none` uncertain, and an uncertain `none` is kept, never deleted. Notable removals: `BUILTIN_RUBRICS` (`./wire`), `otelRunCompleteHook` (`./traces`), `FINDING_SUBJECT_GRAMMAR_PROMPT` and the analyst adapter factories (`./analyst`), the delegate-tool defaults (`./multishot`), and the `EvalRun*` schemas (`./hosted`).
+
+### Added
+
+- `docs/public-api.md` and `pnpm api:census`: every published value export with the consumer that justifies it, classified `production`, `planned`, or `none`, with the evidence for each row and the five blind spots that bound the classification (dynamic imports and namespace binds, repositories outside the sweep, pinned versions, the wire and RPC surfaces, string-keyed dispatch). Consumer evidence lives in `scripts/public-api-consumers.json`, stamped with the commit of every repository read. The census runs on demand: it is a dated reading, not a CI gate.
+---
+
+## [0.156.0] — 2026-08-21
+
+### Added
+
+- Logprob-expectation judge scoring (#637). `llmJudge({ scoring: { method: 'expectation', whenUnavailable } })` asks the provider for the log probabilities of the score token and returns the expected grade over the integer grades the model considered, so two answers that both sample `8` separate by how much mass sat on `7` versus `9`. It requires `scale: 'ten'` — an integer grade is one token and a `[0,1]` float is not — and refuses a grade that did not land in exactly one token instead of approximating it. `whenUnavailable` decides the provider-returns-nothing case: `'fail'` throws, `'sampled'` reads the emitted grade. `JudgeScore` gains `scoringMethod` (what actually produced the number, so a run that fell back reads `'sampled'`) and `distribution` (probability mass per grade). Panels are unchanged; `ensembleJudge` consumes the composite either way. No new dependency: the technique is a scoring-loop change, not a package.
+- `LlmCallRequest.logprobs: { topLogprobs }` sends `logprobs: true` with `top_logprobs`, and `LlmCallResult.logprobs` carries the parsed per-token window from `choices[0].logprobs.content`, or `null` when the provider returned none. A provider that ignores the field is a fact the caller can read, never an inferred distribution. `wrapLlmClient` forwards both, so every `ChatClient` transport carries them.
+---
+
+## [0.155.0] — 2026-08-21
+
+### Added
+
+- `runOptimization({ searchLedger })` and `selfImprove({ searchLedger })` record the candidate search into the canonical `SearchLedger` and return a bounded `searchHistory` receipt (#633). The loop emits the plan (slots = generations x populationSize, one candidate-generation operation per generation, one selection operation, one task per designed scenario-replicate cell), one registration per candidate carrying the exact parent surface it mutated, one attempt per scored cell with the cell's own outcome and accounting, one decision per candidate, and the terminal event. `FileSearchLedger` now has a first-party caller in its own package. The terminal event is appended only when canonical replay accounts for the whole planned denominator, so an interrupted or partly unscored search reports the gap instead of claiming a closed search.
+- `search-plan-extended`: a rolling search appends candidate slots and operations to an existing plan instead of opening a second ledger. Replay merges the first plan with every extension, the generation invariant continues across rounds, and the planless refusal is unchanged. The planned task denominator stays frozen.
+- `gepaOptimizationMethod({ searchLedger: { identity } })` records GEPA's own candidate population — its parent graph and per-scenario selection scores — into the same ledger through `recordCandidatePopulationSearch()`. `compareOptimizationMethods({ searchHistoryPolicy: 'require-complete' })` now accepts a first-party method, which is what `docs/search-history-receipts.md` promised.
+
+---
+
+## [0.154.0] — 2026-08-21
+
+### Added
+
+- Sequential state reconstruction after a process restart (#411, criterion 2). `EProcessState` now carries the running sums `sumX` and `varSum` next to wealth, n, and the parameters, so the snapshot `state()` returns is sufficient to continue the betting test-martingale. `eProcess({ resume })` rebuilds a process from such a snapshot, and `sequentialPairedGate({ resume })` rebuilds the gate's observe-stream from the new exported `SequentialStreamState` (the e-process state plus the gate decision). A process or gate interrupted at any n and resumed from a JSON round-trip of its state produces the identical wealth sequence, observation sequence, decision, and final state as an uninterrupted run. The snapshot never supplies the parameters: a snapshot recorded under a different alpha, maxBet, null boundary, or threshold is refused with a `ValidationError`, as is one whose fields cannot all be true at once (running sums out of range, a latch without its n, a gate decision this configuration could not have reached). `sequentialDecide` needs no snapshot: it is replayed from the generation history it is handed.
+
+---
+
+## [0.153.0] — 2026-08-21
+
+### Changed
+
+- One canonical-JSON encoder (#646, part 1 of 3). Every non-durable digest and stable serialization in the package now delegates to `ledger-core/canonical` (RFC 8785): `canonicalJson`/`contentHash` (the verdict-cache pair the attestation, campaign-manifest, coverage, and trace-repair digests build on), `hashScenarios`/`Dataset.toJsonl`, `serializeFeedbackTrajectoriesJsonl`, the `runControl` default state/action fingerprints, the code-agent-session `configHash`, `canonicalDigest` (loop provenance), and `argHash`. For plain JSON data the bytes — and therefore every persisted digest over plain data — do not change. What changes: a value with no faithful canonical form is refused with `LedgerCanonicalizationError` instead of coerced. `Date`/`toJSON` objects no longer serialize (pass ISO strings), an `undefined`-valued field no longer silently drops or collides with the absent field, and integer-like object keys sort as strings where the sort-into-a-new-object encoders emitted them in numeric enumeration order first.
+- The verdict cache key scheme is `v2:` + the content hash (`VERDICT_CACHE_KEY_SCHEME`). Entries a store holds under the unprefixed scheme miss once and repopulate; no verdict is wrong afterward, only cold.
+- `runControl`'s default fingerprint no longer falls back to `String(value)` for an unserializable state or action — two states that differ in such a field must not fingerprint alike, so it throws; callers with such state supply `stopPolicies.stateFingerprint`/`actionFingerprint`. `argHash` likewise refuses args with no canonical form; uncaptured (`undefined`) args still key to `'undefined'`.
+
+---
+
+## [0.152.0] — 2026-08-21
+
+### Added
+
+- `runCampaign({ cellRetry })` — opt-in bounded in-run retry of failed cells. A cell whose failure the caller's `retryable` predicate accepts is dispatched again in the same slot (same `cellId`, same seed, same cost tags) until it succeeds or `attempts` is exhausted, so one router 503 no longer leaves campaign coverage incomplete and forces `runImprovementLoop` to refuse the holdout comparison. Every attempt charges the shared cost ledger (`costUsd` and `costCallIds` on the final cell cover all attempts); a retried attempt keeps its evidence at `<cell>/failure-receipt.attempt-<n>.json` while a final failure keeps `failure-receipt.json`; the final cell records `retryAttempts`; `abortOnCellError` fires only after the last attempt fails, and a cancelled campaign never retries. The exported `transientDispatchFailure()` predicate retries only dispatch-stage failures that `isTransientTransportFailure` classifies as infrastructure hiccups — a judge-stage failure is never transport. `selfImprove({ cellRetry })` forwards the policy to baseline, candidate, and holdout campaigns. Fail-closed default: no retry unless opted in.
+
+---
+
+## [0.151.0] — 2026-08-20
+
+### Added
+
+- `selectParent` on `runOptimization()` and `selfImprove()` (#632): a policy for which scored surface each generation MUTATES. Absent, the loop stays incumbent-anchored and the recorded `parentSurfaceHash` lineage is a chain. Present, the selector receives the Pareto frontier so far, the measured incumbent, the generation history, and the generation index, and returns one frontier parent; the loop hands it to `propose()` as `currentSurface` plus the new `ProposeContext.parentOutcome`, records it as every candidate's `parentSurfaceHash` / `parentComposite` / `observedDeltaFromParent`, and refuses a parent the run never measured to completion. Promotion is unchanged: a candidate still has to beat the incumbent, and `incumbentOutcome` stays the global bar. `crowdedFrontierParent({ seed })` from `/campaign` is the provided policy, a seeded NSGA-II crowded tournament over `paretoFrontierWithCrowding` that prefers isolated frontier parents and is deterministic per `(seed, generation)`.
+- Two evidence records for the agent-engine integration arc. `agent-engine-shim-live-proof` (MEASURED-ONCE): the Anthropic loopback shim serves an unmodified Claude Code CLI driving a GEPA autoresearch optimization on the published 0.150.2 npm + PyPI packages, fully metered — 8/8 anthropic-wire requests admitted and completed, totalCostUsd 0.029778336 with accountingComplete true, baseline 0.286 -> winner 1.0 on the deterministic toy objective. `gepa-bridge-machinery-certification` (MEASURED-ONCE, negative disclosed): the GEPA bridge machinery is certified on AIME-2025 (150/150 evaluations, 22 proposals, measured-worse candidates rejected, dual-count integrity held), while the lift verdict is NOT measured — two held-out items exceed glm-5.3's 16000-token reasoning envelope / 480s dispatch wall, and the fail-loud comparison refuses partial verdicts by design.
 
 ---
 
@@ -1208,6 +1348,10 @@ threshold and should be re-run on this release.
 
 ## [0.130.1] - 2026-07-26 - safe DSPy disk caching
 
+### Changed
+
+- Doc comments on the public campaign search APIs: `FileSearchLedger`, the three search-ledger error classes, `canonicalDigest` in provenance, and the surface-identity helpers (`87c02e6`, #444).
+
 ### Fixed
 
 - `DspyJudgeMetric` now rejects DSPy's unrestricted disk-cache pickle mode at construction and on every metric call.
@@ -1215,6 +1359,10 @@ threshold and should be re-run on this release.
 
 ## [0.130.0] - 2026-07-26 - current dependency and build cohort
 
+### Added
+
+- `./ledger-core` subpath: the generic journal machinery extracted from `search-ledger` (`25ce61b`, #441). It holds the canonical-JSON SHA-256 hash chain, idempotent append by `eventId`, chain verification, replay to projection, the per-path mutex with an atomic lock file, and the fsync discipline, with no campaign vocabulary. `search-ledger` is now the campaign codec bound to `FileLedgerJournal`; files, error classes, messages, and check order are unchanged.
+
 ### Changed
 
 - Updated Agent Core to `0.4.24` and Agent Interface to `0.35.0`.

package/README.md

@@ -110,21 +110,25 @@ Every row is a function you call. Each links to a runnable example.
 ## Configure Model Calls
 
 Benchmarks, user drivers, executors, built-in judges, completion checkers, and judge adapters all take the same `ChatClient`.
+You own model execution: Agent Eval issues no provider request and never receives a provider credential.
 
 ```ts
 import { createChatClient } from '@tangle-network/agent-eval'
 
 const chat = createChatClient({
-  transport: 'router',
-  apiKey: process.env.TANGLE_API_KEY!,
+  transport: 'custom',
   defaultModel: 'openai/gpt-4.1',
   maximumAttempts: 3,
+  chat: async (request, opts) => myProviderClient(request, opts),
 })
 ```
 
-Use `direct-provider` for an OpenAI-compatible endpoint, `cli-bridge` for a local subscription, `sandbox-sdk` for Sandbox, or `custom` to adapt another SDK.
+On Agent Runtime, `profileChatClient({ profile, executor, context })` from `@tangle-network/agent-runtime/kernel` is that transport: every call runs one exact `AgentProfile` and reports its measured usage, retries, and served model identity.
+Use `sandbox-sdk` for Sandbox and `mock` in tests.
 A custom adapter must return a `ChatResponse` and declare `maximumAttempts` before a capped cost account can dispatch it.
 
+`ChatResponse` carries the whole execution record across that boundary: the served model id, measured input/output/reasoning/cached tokens, billed USD or an explicit unknown, the finish reason, and the per-token log probabilities the expectation judge scores on.
+
 The official GEPA and SkillOpt optimizers run through a Python bridge.
 Install commands, version pins, and the reason for each pin:
 [GEPA](./docs/campaign-proposers.md#install-official-gepa),

package/dist/{active-curriculum-C4mk67HP.js → active-curriculum-CD5TU2yW.js}

@@ -1,3 +1,4 @@
+import { i as makeRng } from "./internal-BDHPCnjk.js";
 import { n as observedScore } from "./reward-nw2xZGZG.js";
 //#region src/rl/active-curriculum.ts
 /**
@@ -103,7 +104,7 @@ function thompsonCurriculum(observations, candidateCells, opts) {
 	const threshold = opts.decisionThreshold ?? .5;
 	const alpha0 = opts.priorAlpha ?? 1;
 	const beta0 = opts.priorBeta ?? 1;
-	const rng = makeRng(opts.seed);
+	const rng = makeRng(opts.seed, observations.map((observation) => observation.score));
 	const grouped = /* @__PURE__ */ new Map();
 	for (const o of observations) {
 		const k = `${o.variantId}::${o.scenarioId}`;
@@ -168,17 +169,6 @@ function observationsFromRunRecords(runs, opts = {}) {
 	}
 	return out;
 }
-function makeRng(seed) {
-	if (seed === void 0) return Math.random;
-	let s = seed >>> 0;
-	return () => {
-		s = s + 1831565813 >>> 0;
-		let t = s;
-		t = Math.imul(t ^ t >>> 15, t | 1);
-		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-		return ((t ^ t >>> 14) >>> 0) / 4294967296;
-	};
-}
 /**
 * Sample from Beta(α, β) via the Marsaglia–Tsang method using two Gamma
 * variates. Accuracy is good for α, β > 1; we floor the parameters at 1
@@ -211,4 +201,4 @@ function sampleGamma(shape, rng) {
 //#endregion
 export { thompsonCurriculum as n, varianceBasedCurriculum as r, observationsFromRunRecords as t };
 
-//# sourceMappingURL=active-curriculum-C4mk67HP.js.map
+//# sourceMappingURL=active-curriculum-CD5TU2yW.js.map

package/dist/active-curriculum-CD5TU2yW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-curriculum-CD5TU2yW.js","names":[],"sources":["../src/rl/active-curriculum.ts"],"sourcesContent":["/**\n * Adaptive curriculum / active scenario selection.\n *\n * Fixed scenario sets waste sample budget on cells the policy already\n * passes (no information left) and cells the policy never passes (no\n * gradient available either). Active learning over scenarios fixes this\n * by allocating the next sample budget to cells where the policy's\n * outcome is *uncertain* — those carry the most decision-relevant signal.\n *\n * This module ships two complementary strategies:\n *\n *   1. **Variance-based** — score each (variant, scenario) cell by the\n *      empirical variance of past observations. Allocate next-round budget\n *      proportional to variance. Standard active-learning-by-uncertainty\n *      heuristic; works well when the policy is non-deterministic and\n *      cells differ in observation noise.\n *\n *   2. **Bandit-based (Thompson sampling)** — model each (variant,\n *      scenario) cell as a Beta-Bernoulli arm; sample a posterior; pick\n *      cells whose posterior mean is closest to the per-scenario decision\n *      threshold. The right primitive when scenarios are\n *      \"pass/fail\" rather than continuous, and when promotion gates fire\n *      at a known threshold (e.g., 0.5).\n *\n * The output is a *next-round budget allocation* — a list of (variant,\n * scenario, count) triples. The consumer's matrix runner consumes the\n * allocation, runs those cells, feeds the new observations back. Loop.\n *\n * Out of scope (deliberate): scenario *generation* — that's the\n * adversarial primitive's job. This module allocates over an existing\n * scenario pool.\n */\n\nimport { observedScore } from '../rollout/reward'\nimport type { RunRecord } from '../run-record'\nimport { makeRng } from '../statistics/internal'\n\nexport interface CellObservation {\n  variantId: string\n  scenarioId: string\n  /** Observed score in [0, 1]. */\n  score: number\n  /** For Bernoulli arms — derive from the score with a threshold if needed. */\n  pass?: boolean\n}\n\nexport interface CurriculumAllocation {\n  variantId: string\n  scenarioId: string\n  /** How many additional reps to run on this cell. */\n  count: number\n  /** Strategy-specific reason for the allocation. */\n  reason: string\n}\n\nexport interface VarianceCurriculumOptions {\n  /** Total reps to allocate across all cells. */\n  budget: number\n  /**\n   * Smoothing prior on variance — keeps the allocator from concentrating\n   * on a cell with one observation just because its 1-sample variance is\n   * 0. Default 0.05.\n   */\n  variancePrior?: number\n  /**\n   * Minimum reps per cell — even when the variance estimate is low, give\n   * every cell at least this many. Default 1.\n   */\n  floorPerCell?: number\n}\n\n/**\n * Variance-proportional allocation. For each cell, estimate variance from\n * past observations + a prior, then allocate the budget proportional to\n * (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule\n * (Neyman 1934) that balances \"explore noisy cells\" with \"explore\n * under-sampled cells.\"\n */\nexport function varianceBasedCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: VarianceCurriculumOptions,\n): CurriculumAllocation[] {\n  const variancePrior = opts.variancePrior ?? 0.05\n  const floor = opts.floorPerCell ?? 1\n  const budget = opts.budget\n\n  const grouped = new Map<string, number[]>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const arr = grouped.get(k) ?? []\n    arr.push(o.score)\n    grouped.set(k, arr)\n  }\n\n  const cellStats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const samples = grouped.get(k) ?? []\n    const n = samples.length\n    const mean = n === 0 ? 0.5 : samples.reduce((s, v) => s + v, 0) / n\n    const variance =\n      n < 2\n        ? variancePrior\n        : samples.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1) + variancePrior\n    // Neyman optimal allocation: weight ∝ √variance; add √(1/n) to break\n    // ties toward under-sampled cells.\n    const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n))\n    return { variantId: c.variantId, scenarioId: c.scenarioId, n, mean, variance, weight }\n  })\n\n  // Reserve floor*N for the floor; allocate the rest proportional to weight.\n  const floorTotal = floor * cellStats.length\n  if (floorTotal >= budget) {\n    const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)))\n    return cellStats.map((c) => ({\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: each,\n      reason: `floor allocation (budget tight; n=${c.n})`,\n    }))\n  }\n  const remaining = budget - floorTotal\n  const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0)\n  return cellStats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * remaining)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: floor + proportional,\n      reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`,\n    }\n  })\n}\n\nexport interface ThompsonCurriculumOptions {\n  budget: number\n  /**\n   * The per-scenario decision threshold. Cells whose posterior mean is\n   * closest to this get the most budget — that's where the next observation\n   * has the highest information value for the gate decision. Default 0.5.\n   */\n  decisionThreshold?: number\n  /** Beta prior parameters. Default α=β=1 (uniform). */\n  priorAlpha?: number\n  priorBeta?: number\n  /** Seed the Thompson sampler. Absent, the seed is derived from the observed\n   *  scores, so the same observations reproduce the same allocation. */\n  seed?: number\n}\n\n/**\n * Thompson-sampling-style allocation for pass/fail cells. For each cell:\n *\n *   - Maintain Beta(α + passes, β + failures) posterior on pass-rate\n *   - Allocation weight ∝ exp(-((sampledMean - threshold) / σ)^2):\n *     cells whose sampled posterior straddles the decision boundary get\n *     the most weight; cells already clearly above or below get less.\n *\n * This is the right primitive when promotion gates fire at a known\n * threshold and you want to sharpen the posterior near the boundary.\n */\nexport function thompsonCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: ThompsonCurriculumOptions,\n): CurriculumAllocation[] {\n  const threshold = opts.decisionThreshold ?? 0.5\n  const alpha0 = opts.priorAlpha ?? 1\n  const beta0 = opts.priorBeta ?? 1\n  const rng = makeRng(\n    opts.seed,\n    observations.map((observation) => observation.score),\n  )\n\n  const grouped = new Map<string, { passes: number; failures: number }>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const pass = o.pass ?? o.score >= threshold\n    if (pass) cur.passes += 1\n    else cur.failures += 1\n    grouped.set(k, cur)\n  }\n\n  const stats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const a = alpha0 + cur.passes\n    const b = beta0 + cur.failures\n    // Sample a single Beta draw — the Thompson signal.\n    const sampled = sampleBeta(a, b, rng)\n    const distance = Math.abs(sampled - threshold)\n    // Information-near-threshold weight: closer = higher.\n    // Use Gaussian-shaped kernel with σ tuned to posterior std.\n    const variance = (a * b) / ((a + b) ** 2 * (a + b + 1))\n    const sigma = Math.max(0.05, Math.sqrt(variance))\n    const weight = Math.exp(-((distance / sigma) ** 2))\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      n: cur.passes + cur.failures,\n      sampled,\n      sigma,\n      weight,\n      a,\n      b,\n    }\n  })\n\n  const totalWeight = stats.reduce((s, c) => s + c.weight, 0)\n  return stats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * opts.budget)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: Math.max(0, proportional),\n      reason: `Beta(${c.a.toFixed(1)},${c.b.toFixed(1)}) sample=${c.sampled.toFixed(3)} (target ${threshold})`,\n    }\n  })\n}\n\n/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */\nexport function observationsFromRunRecords(\n  runs: RunRecord[],\n  opts: { passThreshold?: number; useHoldout?: boolean } = {},\n): CellObservation[] {\n  const threshold = opts.passThreshold ?? 0.5\n  const useHoldout = opts.useHoldout ?? true\n  const out: CellObservation[] = []\n  for (const r of runs) {\n    if (!r.scenarioId) continue\n    // Ungated on purpose, and the precedence is caller policy, not a default:\n    // `useHoldout: false` means \"score this curriculum on the search split when\n    // both exist\". This feeds sampling COUNTS, not an exported reward. Known\n    // risk: a gamed run's high score inflates the cell's Beta posterior, so the\n    // curriculum stops sampling a cell it wrongly believes is solved. The fix\n    // for that is an upstream filter on gated records — zeroing the score here\n    // would push the posterior the opposite way and be equally wrong.\n    const score = observedScore(r, useHoldout ? 'holdout' : 'search')\n    if (typeof score !== 'number' || !Number.isFinite(score)) continue\n    out.push({\n      variantId: r.candidateId,\n      scenarioId: r.scenarioId,\n      score,\n      pass: score >= threshold,\n    })\n  }\n  return out\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────\n\n/**\n * Sample from Beta(α, β) via the Marsaglia–Tsang method using two Gamma\n * variates. Accuracy is good for α, β > 1; we floor the parameters at 1\n * to avoid degenerate cases.\n */\nfunction sampleBeta(alpha: number, beta: number, rng: () => number): number {\n  const a = Math.max(1, alpha)\n  const b = Math.max(1, beta)\n  const x = sampleGamma(a, rng)\n  const y = sampleGamma(b, rng)\n  return x / (x + y)\n}\n\nfunction sampleGamma(shape: number, rng: () => number): number {\n  // Marsaglia–Tsang for shape ≥ 1.\n  const d = shape - 1 / 3\n  const c = 1 / Math.sqrt(9 * d)\n  while (true) {\n    let x: number\n    let v: number\n    do {\n      const u1 = rng() || 1e-12\n      const u2 = rng() || 1e-12\n      // Box-Muller for a normal sample.\n      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2)\n      v = 1 + c * x\n    } while (v <= 0)\n    v = v * v * v\n    const u = rng()\n    if (u < 1 - 0.0331 * x ** 4) return d * v\n    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v\n  }\n}\n"],"mappings":"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"}

package/dist/{agent-profile-cell-BkcRDikH.d.ts → agent-profile-cell-CTOZJUuE.d.ts}

@@ -50,7 +50,9 @@ declare class AgentProfileCellValidationError extends ValidationError {
 declare function buildAgentProfileCell(input: AgentProfileCellInput): Promise<AgentProfileCell>;
 declare function agentProfileCellHashMaterial(cell: AgentProfileCell): Omit<AgentProfileCell, 'cellId'>;
 /**
- * Verify an `AgentProfileCell`'s `cellId` matches the sha256 of its hash-material fields, confirming the record has not been tampered with.
+ * Verify an `AgentProfileCell`'s `cellId` matches the sha256 of its hash-material
+ * fields, confirming the record has not been tampered with. The id names its own
+ * digest scheme, so a cell minted by an earlier release verifies under that scheme.
  */
 declare function verifyAgentProfileCell(cell: AgentProfileCell): Promise<boolean>;
 declare function validateAgentProfileCell(input: unknown): AgentProfileCell;
@@ -105,4 +107,4 @@ type AgentInterfaceProfileLike = AgentProfile & {
 declare function buildAgentInterfaceProfileCell(profile: AgentInterfaceProfileLike, input: Omit<AgentProfileCellInput, 'profileId' | 'sourceProfile'>): Promise<AgentProfileCell>;
 //#endregion
 export { verifyAgentProfileCell as C, validateAgentProfileCell as S, buildAgentInterfaceProfileCell as _, AgentProfileCellSchemaVersion as a, requireAgentProfileCell as b, AgentProfileHarness as c, AgentProfileKind as d, AgentProfileSource as f, assertRunAgentProfileCell as g, agentProfileCellKey as h, AgentProfileCellInput as i, AgentProfileJson as l, agentProfileCellHashMaterial as m, AgentInterfaceProfileLike as n, AgentProfileCellValidationError as o, AgentProfileSourceInput as p, AgentProfileCell as r, AgentProfileDimensionValue as s, AGENT_PROFILE_KINDS as t, AgentProfileJsonObject as u, buildAgentProfileCell as v, toAgentProfileJson as x, groupRunsByAgentProfileCell as y };
-//# sourceMappingURL=agent-profile-cell-BkcRDikH.d.ts.map
+//# sourceMappingURL=agent-profile-cell-CTOZJUuE.d.ts.map

package/dist/agent-profile-cell-CTOZJUuE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-profile-cell-CTOZJUuE.d.ts","names":[],"sources":["../src/agent-profile-cell.ts"],"mappings":";;;KAKY;KAEA;GAA4B,cAAc;;KAE1C,sDAKR,qBACA;KAEQ;UAEK;;EAEf;;EAEA;;UAGe;EACf;;EAEA;;EAEA,UAAU;;UAGK;EACf;EACA;EACA;;UAGe;EACf;EACA,eAAe;EACf,UAAU;EACV;EACA;EACA,aAAa,eAAe;;UAGb;EACf,eAAe;EACf;EACA;EACA,eAAe;EACf,UAAU;EACV;EACA;EACA,aAAa,eAAe;;cAGjB,wCAAwC;WAC1C;EACT,YAAY,iBAAiB;;iBAgBT,sBACpB,OAAO,wBACN,QAAQ;iBAMK,6BACd,MAAM,mBACL,KAAK;;;;;;iBAWc,uBAAuB,MAAM,mBAAmB;iBA6BtD,yBAAyB,iBAAiB;iBAqB1C,wBAAwB;EACtC;EACA,eAAe;IACb;iBAUY,oBAAoB;EAClC;EACA,eAAe;;iBAKK,0BAA0B;EAC9C;EACA;EACA;EACA,eAAe;IACb,QAAQ;iBAuBI,4BACd;EAAY;EAAe,eAAe;GAC1C,kBAAkB,MAAM,YAAY;;;;;cA0NzB;;;;WAIX;;KAGU,2BAA2B,kCAAkC;;;;;iBAMzD,mBAAmB,iBAAiB;;KAoBxC,4BAA4B;EAAiB;EAAc;;;;;;;;;;;iBAWjD,+BACpB,SAAS,2BACT,OAAO,KAAK,wDACX,QAAQ"}

package/dist/analyst/index.d.ts

@@ -1,19 +1,19 @@
-import { a as MultiLayerVerifier, c as VerifyOptions, o as Severity } from "../multi-layer-verifier-BUaQ4C17.js";
-import { A as SemanticConceptJudgeInput, C as parseFindingSubject, E as createDspyRlmTraceEngine, F as RunScoreWeights, P as RunScore, S as findingSubjectGrammarPromptFor, T as DspyRlmTraceEngineOptions, _ as FINDING_SUBJECT_SYNTAX, a as FAILURE_MODE_KIND_SPEC, b as FindingSubjectStringSchema, c as emitControlIntegrityFindings, d as FindingsStore, f as PersistedFinding, g as FINDING_SUBJECT_KINDS, h as FINDING_SUBJECT_GRAMMAR_PROMPT, i as IMPROVEMENT_KIND_SPEC, j as SemanticConceptJudgeOptions, l as DiffPolicy, m as diffFindings, n as KNOWLEDGE_POISONING_KIND_SPEC, o as CONTROL_INTEGRITY_ANALYST, p as defaultIsMaterial, r as KNOWLEDGE_GAP_KIND_SPEC, s as ControlIntegrityAnalyst, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubject, w as renderFindingSubject, x as KIND_EXPECTED_SUBJECTS, y as FindingSubjectKind } from "../index-Aj3WO3_a.js";
+import { a as MultiLayerVerifier, c as VerifyOptions } from "../multi-layer-verifier-BUaQ4C17.js";
+import { C as DspyRlmTraceEngineOptions, M as RunScore, N as RunScoreWeights, O as SemanticConceptJudgeInput, S as renderFindingSubject, _ as FindingSubject, a as FAILURE_MODE_KIND_SPEC, b as findingSubjectGrammarPromptFor, c as emitControlIntegrityFindings, d as FindingsStore, f as PersistedFinding, g as FINDING_SUBJECT_SYNTAX, h as FINDING_SUBJECT_KINDS, i as IMPROVEMENT_KIND_SPEC, k as SemanticConceptJudgeOptions, l as DiffPolicy, m as diffFindings, n as KNOWLEDGE_POISONING_KIND_SPEC, o as CONTROL_INTEGRITY_ANALYST, p as defaultIsMaterial, r as KNOWLEDGE_GAP_KIND_SPEC, s as ControlIntegrityAnalyst, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubjectKind, w as createDspyRlmTraceEngine, x as parseFindingSubject, y as KIND_EXPECTED_SUBJECTS } from "../index-CGtH1piv.js";
 import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-DbQdN3nO.js";
-import { C as TraceEvent, _ as Span, f as Run, n as BudgetLedgerEntry, t as Artifact } from "../schema-BtVldJ3T.js";
-import { C as SandboxSdkTransportOpts, S as RouterTransportOpts, _ as CliBridgeTransportOpts, a as JudgeInput, b as DirectProviderTransportOpts, f as ChatCallOpts, g as ChatTransport, h as ChatResponse, i as JudgeFn, m as ChatRequest, p as ChatClient, v as CreateChatClientOpts, w as createChatClient, x as MockTransportOpts, y as CustomTransportOpts } from "../types-jUBXJ7Iz.js";
-import { s as TraceStore } from "../store-CT9YIIve.js";
-import "../index-C1ravkGA.js";
-import { I as TraceAnalystSpan, _ as ProposalFinding, a as AnalystInputKind, b as makeFinding, c as AnalystRunInputs, d as AnalystSeverity, f as AnalystUsageReceipt, g as ExecutionProbeRequest, h as ExecutionProbeOutcome, i as AnalystFinding, l as AnalystRunResult, m as ExecutionProbe, n as AnalystContext, o as AnalystRequirements, p as EvidenceRef, r as AnalystCost, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary, v as ProposalFindingOrigin, w as TraceAnalysisStore, x as makeProposalFinding, y as computeFindingId } from "../types-B2NsbrNy.js";
-import { a as createTraceAnalyst, c as runTraceAnalyst, d as deriveEfficiencyFindings, i as TraceAnalystDefinition, l as BehavioralAnalystOptions, n as buildDefaultAnalystRegistry, o as renderPriorFindings, r as CreateTraceAnalystOptions, s as renderUpstreamFindings, t as DefaultAnalystRegistryOptions, u as behavioralAnalyst } from "../default-registry-Cw0Ohdoj.js";
-import { a as ExactAnalystRunPolicySnapshot, c as ExactAnalystSnapshot, d as ExactExecutionComponentSnapshot, i as ExactAnalystRunEvent, l as ExactCapableAnalyst, n as ExactAnalystExecutionPlanSnapshot, o as ExactAnalystRunResult, r as ExactAnalystRunCompletion, s as ExactAnalystRunSummary, t as ExactAnalystBudgetSnapshot, u as ExactExecutionComponentIdentity } from "../exact-types-ccQAyut1.js";
-import { a as ExactAnalystBudgetPolicy, c as RegistryRunOpts, i as BudgetPolicy, l as assertExactRegistryRunOpts, n as AnalystRegistry, o as ExactAnalystRunExecutionError, r as AnalystRegistryOptions, s as ExactRegistryRunOpts, t as AnalystHooks } from "../registry-BQwrSYpC.js";
-import { C as scoreAnalystFindings, S as traceStoreEvidenceResolver, _ as AnalystIssueExpectation, a as AnalystBenchmarkLabelState, b as registryBenchmarkRunner, c as AnalystBenchmarkProvenance, d as AnalystBenchmarkSummary, f as AnalystEvidenceExpectation, g as AnalystFindingScore, h as AnalystEvidenceResolver, i as AnalystBenchmarkError, l as AnalystBenchmarkResult, m as AnalystEvidenceResolutionError, n as AnalystBenchmarkDatasetRef, o as AnalystBenchmarkObservation, p as AnalystEvidenceResolution, r as AnalystBenchmarkDescriptor, s as AnalystBenchmarkOutput, t as AnalystBenchmarkCase, u as AnalystBenchmarkRunner, v as AnalystLatencyDistribution, x as runAnalystBenchmark, y as RunAnalystBenchmarkOptions } from "../benchmark-BtAWA8nT.js";
-import { f as ExternalOptimizerModelExecutionObservation, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall } from "../external-optimizer-contracts-DbLsm4Po.js";
+import { C as TraceEvent, _ as Span, f as Run, n as BudgetLedgerEntry, t as Artifact } from "../schema-Bjgdsn73.js";
+import { s as TraceStore } from "../store-B06JdC56.js";
+import "../index-vrJugRal.js";
+import { _ as CreateChatClientOpts, a as JudgeInput, b as SandboxSdkTransportOpts, f as ChatCallOpts, g as ChatTransport, h as ChatResponse, i as JudgeFn, m as ChatRequest, p as ChatClient, v as CustomTransportOpts, x as createChatClient, y as MockTransportOpts } from "../types-Bfk0uxRj.js";
+import { I as TraceAnalystSpan, _ as ProposalFinding, a as AnalystInputKind, b as makeFinding, c as AnalystRunInputs, d as AnalystSeverity, f as AnalystUsageReceipt, g as ExecutionProbeRequest, h as ExecutionProbeOutcome, i as AnalystFinding, l as AnalystRunResult, m as ExecutionProbe, n as AnalystContext, o as AnalystRequirements, p as EvidenceRef, r as AnalystCost, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary, v as ProposalFindingOrigin, w as TraceAnalysisStore, x as makeProposalFinding, y as computeFindingId } from "../types-D9ssmxKL.js";
+import { a as createTraceAnalyst, c as BehavioralAnalystOptions, i as TraceAnalystDefinition, l as behavioralAnalyst, n as buildDefaultAnalystRegistry, o as renderPriorFindings, r as CreateTraceAnalystOptions, s as runTraceAnalyst, t as DefaultAnalystRegistryOptions, u as deriveEfficiencyFindings } from "../default-registry-G9CKMNkc.js";
+import { a as ExactAnalystRunPolicySnapshot, c as ExactAnalystSnapshot, d as ExactExecutionComponentSnapshot, i as ExactAnalystRunEvent, l as ExactCapableAnalyst, n as ExactAnalystExecutionPlanSnapshot, o as ExactAnalystRunResult, r as ExactAnalystRunCompletion, s as ExactAnalystRunSummary, t as ExactAnalystBudgetSnapshot, u as ExactExecutionComponentIdentity } from "../exact-types-qnexxJ1Z.js";
+import { a as ExactAnalystBudgetPolicy, c as RegistryRunOpts, i as BudgetPolicy, n as AnalystRegistry, o as ExactAnalystRunExecutionError, r as AnalystRegistryOptions, s as ExactRegistryRunOpts, t as AnalystHooks } from "../registry-8You7OK1.js";
+import { C as scoreAnalystFindings, S as traceStoreEvidenceResolver, _ as AnalystIssueExpectation, a as AnalystBenchmarkLabelState, b as registryBenchmarkRunner, c as AnalystBenchmarkProvenance, d as AnalystBenchmarkSummary, f as AnalystEvidenceExpectation, g as AnalystFindingScore, h as AnalystEvidenceResolver, i as AnalystBenchmarkError, l as AnalystBenchmarkResult, m as AnalystEvidenceResolutionError, n as AnalystBenchmarkDatasetRef, o as AnalystBenchmarkObservation, p as AnalystEvidenceResolution, r as AnalystBenchmarkDescriptor, s as AnalystBenchmarkOutput, t as AnalystBenchmarkCase, u as AnalystBenchmarkRunner, v as AnalystLatencyDistribution, x as runAnalystBenchmark, y as RunAnalystBenchmarkOptions } from "../benchmark-CGPp-kDC.js";
+import { f as ExternalOptimizerModelExecutionObservation, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall } from "../external-optimizer-contracts-szBJ_1vh.js";
 import { t as AgentProfile } from "../agent-profile-B9_GGsG8.js";
-import { a as TraceAnalystLimits, c as RAW_FINDING_SCHEMA_PROMPT, d as RawAnalystFinding, f as RawAnalystFindingSchema, i as TraceAnalysisEngineResult, l as RawAnalystEvidence, m as parseRawFinding, n as TraceAnalysisEngine, o as resolveTraceAnalystLimits, p as evidenceRefsFromRawFinding, r as TraceAnalysisEngineRequest, s as ANALYST_SEVERITIES, t as DEFAULT_TRACE_ANALYST_LIMITS, u as RawAnalystEvidenceSchema } from "../engine-BLzhNzoY.js";
-import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-groups-B4tqh8jB.js";
+import { a as resolveTraceAnalystLimits, c as RawAnalystFinding, d as parseRawFinding, i as TraceAnalystLimits, l as RawAnalystFindingSchema, n as TraceAnalysisEngineRequest, o as RAW_FINDING_SCHEMA_PROMPT, r as TraceAnalysisEngineResult, s as RawAnalystEvidence, t as TraceAnalysisEngine, u as evidenceRefsFromRawFinding } from "../engine-Cu5qD5Fc.js";
+import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-groups-Ci8i9ErB.js";
 import { i as nodeHttpPrimeBridgeTransport, n as PrimeBridgeTransportRequest, r as PrimeBridgeTransportResult, t as PrimeBridgeTransport } from "../prime-bridge-transport-6feEglLf.js";
 import { z } from "zod";
 //#region src/run-critic.d.ts
@@ -39,7 +39,6 @@ declare class RunCritic {
 }
 //#endregion
 //#region src/analyst/adapters.d.ts
-declare function liftSeverity(s: Severity): AnalystSeverity;
 interface VerifierAdapterOpts<Env> {
   id?: string;
   area?: string;
@@ -75,11 +74,11 @@ interface SemanticConceptJudgeAdapterOpts {
   id?: string;
   area?: string;
   /** Registry context owns cancellation and the per-analyst cost ledger. */
-  options?: Omit<SemanticConceptJudgeOptions, 'costLedger' | 'signal'>;
+  options: Omit<SemanticConceptJudgeOptions, 'costLedger' | 'signal'>;
   /** Maximum post-cancellation wait for a provider receipt. Default 5 seconds. */
   settlementTimeoutMs?: number;
 }
-declare function createSemanticConceptJudgeAdapter(opts?: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
+declare function createSemanticConceptJudgeAdapter(opts: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
 //#endregion
 //#region src/analyst/benchmark-agentrx-calibration.d.ts
 declare const AGENT_RX_UPSTREAM_REVISION = "f228165bfec60a801fd5fedd9d8ffe0f9de0c69d";
@@ -1293,25 +1292,16 @@ interface AnalystBenchmarkCommandConfig {
   resume: boolean;
 }
 declare function runAnalystBenchmarkCommand(argv: readonly string[], env?: NodeJS.ProcessEnv, dependencies?: AnalystBenchmarkCommandDependencies): Promise<number>;
-declare const ANALYST_BENCHMARK_HELP = "agent-eval analyst-benchmark\n\nRun the recursive DSPy trace analyst against public AgentRx or CodeTraceBench labels.\n\nRequired:\n  --dataset agentrx|codetracebench\n  --analyst dspy-rlm|direct|prime  Scored analyst. Default: dspy-rlm.\n                                   'direct' is the one-shot comparison arm.\n                                   'prime' is the RLM coding agent behind an\n                                   OpenAI-compatible cli-bridge (codetracebench\n                                   only; see docs/prime-analyst.md)\n  --labels <dataset.json|dataset.jsonl>\n  --trace-dir <one-trace-per-file OTLP JSONL directory>\n  --artifact-dir <extracted artifact root>  Required for CodeTraceBench\n  --out <new output directory>\n  --revision <full 40- or 64-character hex digest>\n  --split <dataset split>\n  --model-owner-module <module>   dspy-rlm|direct only. Module exporting\n                                   createModelExecutionOwner; the owner keeps\n                                   provider credentials and policy\n  --model <provider model id>      For prime, the bridge model id in\n                                   <backend>/<provider>/<model> form, e.g.\n                                   prime/zai/glm-5.2\n  --limit <positive case count>\n\nControls:\n  --resume                         Continue an interrupted run in --out\n  --bridge-url <url>               prime only. OpenAI-compatible cli-bridge\n                                   base URL. Default: http://localhost:4181\n  --no-repair                      prime only. Disable the bounded repair turn\n                                   for a structurally malformed reply\n  --seed <integer>                 Case-selection and comparison seed. Default: 0\n  --concurrency <positive integer> Parallel benchmark jobs. Default: 1\n  --repetitions <positive integer> Runs per case and runner. Default: 1\n  --rlm-samples <positive integer> Recursive-engine runs per case; above 1 the\n                                   step-level majority consensus is scored\n                                   (CodeTraceBench + dspy-rlm only). Default: 1\n  --instructions-file <path>       Replace the recursive analyst instructions\n                                   with this file's text (dspy-rlm only). The\n                                   recorded protocol digest binds the stock\n                                   protocol to the override text, and\n                                   result.json records instructionsOverrideSha256.\n  --max-output-tokens <positive>   Model output limit per call. Default: 16384\n  --max-reasoning-tokens <integer> Reasoning-token limit per call. Default: 65536\n  --max-model-requests <positive>  Caller-owned model calls per analysis.\n                                   Default: max iterations + model calls + 1\n  --max-model-request-bytes <positive>   Default: 16777216\n  --max-model-response-bytes <positive>  Default: 4194304\n  --model-request-timeout-ms <positive>  Default: --timeout-ms\n  --max-iterations <positive>      Recursive iterations per analysis. Default: 14\n  --max-llm-calls <positive>       DSPy model calls per analysis. Default: 8\n  --max-tool-calls <positive>      Trace-tool calls per analysis. Default: 80\n  --max-analysis-output-chars <positive> Default: 8000\n  --trace-tool-request-bytes <positive>  Default: 1000000\n  --trace-tool-response-bytes <positive> Default: 4000000\n  --trace-tool-timeout-ms <positive>     Default: 60000\n  --max-process-input-bytes <positive>   Default: 67108864\n  --max-process-result-bytes <positive>  Default: 4194304\n  --max-process-output-chars <positive>  Default: 64000\n  --python <executable>             Python with agent-eval-rpc[dspy]. Default: python\n  --timeout-ms <positive>          Model analyst deadline per case. Default: 300000\n  --max-cost-usd <positive>        Run-wide spend limit. Default: 5\n  --max-artifact-bytes <positive>  Final evidence bytes per case. Default: 8388608\n\nWrites result.json with every observation, metric, usage field, error, comparison,\ninput digest, artifact digest, case distribution, selected case id, and explicit\nunknown cost. Limited deterministic-hash subsets are marked non-representative.\nCompleted observations are fsynced to observations.jsonl. Shareable output is in\nresult.json and report.md. Machine-local paths, execution-owner module, and command\nare isolated in run.local.json. Provider credentials never enter this command.";
 //#endregion
 //#region src/analyst/benchmark-implementation.d.ts
 declare const ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM = "sha256-canonical-source-manifest";
 declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM = "sha256-canonical-file-manifest";
 declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES: readonly string[];
-declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "61ad75e662e240404f523d7dad66e18145df9c35b1ce8630468970fef2a00162";
-/** The published benchmark evidence was produced at this package version, by
- * the retired one-shot direct runner, before trace analysts moved to the
- * recursive DSPy RLM engine. Both evidence digests below are historical facts
- * about that artifact: the current implementation and dependency manifest have
- * since changed, so they cannot describe the current engine. A fresh certified
- * run must replace the published evidence before any accuracy number is
- * attributed to the engine that ships today. */
-declare const ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION = "0.137.0";
+declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "6de51aaf48adb3be31601f2e53fbf06a4d407fa16a8c33156caa41bf8c21b09f";
 declare const ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 = "1e03f2daed356d60316aabefb407ec1e437ac94d408d61eea4ae096e9c6fbb5b";
 declare const ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 = "4dba263b6256a30d56c7fdb2d992d3a953c0035d731f359b704db806f68f75ac";
 declare const ANALYST_BENCHMARK_IMPLEMENTATION_FILES: readonly string[];
-declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "40b66a9ab0dce2cfc8da9e3bfac96665f79e3bd666ba8e5d9a2b31d2d8a2c161";
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "6631709758e46ab562765d81bc16871fa7931ec86ba334cd85918904f3b74196";
 declare function analystBenchmarkImplementationDigest(): string;
 declare function analystBenchmarkDependencyLockDigest(): string;
 //#endregion
@@ -1470,13 +1460,6 @@ declare function stripCodeFences(text: string): string;
  * then `JSON.parse`. Returns `undefined` (never throws) when unrecoverable.
  */
 declare function coerceJson(text: string): unknown;
-/**
- * Coerce arbitrary actor/structurer output into an array of candidate finding
- * rows: a JSON string → parse; a single object → 1-element array; an array →
- * as-is; anything else → []. Callers still run each row through Zod
- * (`parseRawFinding`) — this only fixes the shape and never invents fields.
- */
-declare function coerceToFindingRows(raw: unknown): unknown[];
 //#endregion
 //#region src/analyst/prime-protocol.d.ts
 /**
@@ -1729,5 +1712,5 @@ declare function isProposalFinding(finding: unknown): finding is ProposalFinding
  */
 declare function assertProposalFindings(findings: unknown, context?: string): ReadonlyArray<ProposalFinding>;
 //#endregion
-export { AGENT_RX_UPSTREAM_REVISION, ANALYST_BENCHMARK_COST_LEDGER_FILE, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION, ANALYST_BENCHMARK_HELP, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, ANALYST_SEVERITIES, type AgentRxBenchmarkCaseOptions, type AgentRxCalibrationRunnerSummary, type AgentRxCalibrationSummary, type AgentRxFailure, type AgentRxPrediction, type AgentRxPredictionReport, type AgentRxRow, type Analyst, type AnalystBenchmarkArtifact, type AnalystBenchmarkCase, type AnalystBenchmarkCommandConfig, type AnalystBenchmarkCommandDependencies, type AnalystBenchmarkDatasetRef, type AnalystBenchmarkDescriptor, type AnalystBenchmarkError, type AnalystBenchmarkLabelState, type AnalystBenchmarkLocalRunReceipt, type AnalystBenchmarkObservation, type AnalystBenchmarkOutput, type AnalystBenchmarkProgressRow, type AnalystBenchmarkProvenance, type AnalystBenchmarkResult, type AnalystBenchmarkRunIdentity, type AnalystBenchmarkRunManifest, type AnalystBenchmarkRunner, type AnalystBenchmarkSummary, type AnalystBudgetDeclaration, type AnalystComparisonMetric, type AnalystContext, type AnalystCost, type AnalystDefinition, type AnalystDefinitionAsymmetry, type AnalystDefinitionAsymmetryReport, type AnalystEvidenceBinding, type AnalystEvidenceExpectation, type AnalystEvidenceResolution, type AnalystEvidenceResolutionError, type AnalystEvidenceResolver, AnalystExpressivenessError, type AnalystFinding, type AnalystFindingScore, type AnalystHooks, type AnalystInputKind, type AnalystInstructionsOverride, type AnalystIssueExpectation, type AnalystLatencyDistribution, type AnalystMetricComparison, type AnalystProfileFragment, AnalystRegistry, type AnalystRegistryOptions, type AnalystRepairDeclaration, type AnalystRequirements, type AnalystRowExpansion, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystRunnerComparison, type AnalystSeverity, type AnalystTransportBinding, type AnalystUsageReceipt, type BehavioralAnalystOptions, type BudgetPolicy, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTransport, type ChunkedEvidenceBinding, type CliBridgeTransportOpts, type CodeTraceBenchCaseOptions, type CodeTraceBenchLabelOptions, type CodeTraceBenchLabelSet, type CodeTraceBenchRow, type CodeTraceBlockDiagnostics, type CodeTraceCalibrationRunnerSummary, type CodeTraceCalibrationSummary, type CodeTraceFailureBlock, type CodeTraceStageAnnotation, type CodeTracerLabelGroup, type CodeTracerPredictionAdapterOptions, type CodeTracerPredictions, type CodeTracerStepLabel, ControlIntegrityAnalyst, type CreateChatClientOpts, type CreateTraceAnalystOptions, type CustomTransportOpts, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, DEFAULT_TRACE_ANALYST_KINDS, DEFAULT_TRACE_ANALYST_LIMITS, type DecodedReply, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DirectProviderTransportOpts, type DspyRlmTraceEngineOptions, type EvidenceProjection, type EvidenceRef, type ExactAnalystBudgetPolicy, type ExactAnalystBudgetSnapshot, type ExactAnalystExecutionPlanSnapshot, type ExactAnalystRunCompletion, type ExactAnalystRunEvent, ExactAnalystRunExecutionError, type ExactAnalystRunPolicySnapshot, type ExactAnalystRunResult, type ExactAnalystRunSummary, type ExactAnalystSnapshot, type ExactCapableAnalyst, type ExactExecutionComponentIdentity, type ExactExecutionComponentSnapshot, type ExactRegistryRunOpts, type ExecutionProbe, type ExecutionProbeOutcome, type ExecutionProbeRequest, type ExpandRowsArgs, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_GRAMMAR_PROMPT, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, FindingSubjectStringSchema, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type InlineEvidenceBinding, type JudgeAdapterOpts, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, type MockTransportOpts, type PersistedFinding, type PreparedPublicAnalystBenchmark, type PrimeBenchmarkRunnerOptions, type PrimeBridgeTransport, type PrimeBridgeTransportRequest, type PrimeBridgeTransportResult, type PrimeCodeTraceDefinitionArgs, type PrimeExchangeOptions, type PrimeExchangeOutcome, type PrimeFailure, type PrimeProjectionDelivery, type PrimeProjectionOutcome, type PrimeProjectionSource, type PrimePromptSpec, type PrimeProtocolIdentity, type PrimeRawUsage, type PrimeRejectedRow, type PrimeRepairPromptSpec, type PrimeRepairState, type PrimeReplyContract, type PrimeRowDecoded, type PrimeTurnRecord, type ProposalFinding, type ProposalFindingOrigin, type PublicAnalystBenchmarkDataset, type PublicAnalystBenchmarkModelConfig, type PublicAnalystBenchmarkModelOwner, type PublicAnalystBenchmarkModelSettings, type PublicBenchmarkDistributions, type PublicBenchmarkModelPrediction, type PublicBenchmarkSelectionReport, type PublicBenchmarkValueDistribution, type PublicDirectDefinitionArgs, type PublicRlmDefinitionArgs, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, RawAnalystEvidenceSchema, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type ReplVariableConsensusPort, type ReplVariableEvidenceBinding, type ReplyContract, type ReplyEnvelope, type ReplyRowDecoded, type ReplyRowRejection, type RouterTransportOpts, type RunAnalystBenchmarkOptions, type RunCriticAdapterOpts, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, SkillUsageAnalyst, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifierAdapterOpts, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystDefinitionAsymmetries, analystDefinitionProtocolSha256, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, assertExactRegistryRunOpts, assertProposalFindings, behavioralAnalyst, bindAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, coerceToFindingRows, compareAnalystRunners, computeFindingId, createChatClient, createDspyRlmTraceEngine, createJudgeAdapter, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalyst, createVerifierAdapter, decodeReplyRows, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingSubjectGrammarPromptFor, isProposalFinding, liftSeverity, loadCodeTraceVerificationArtifacts, loadPublicBenchmarkRows, makeFinding, makeProposalFinding, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizeAgentRxCategory, normalizeBenchmarkLabel, normalizePrimeUsage, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, primeAnalystProtocolSha256, primeCodeTraceAnalystDefinition, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkRlmInstructions, publicBenchmarkSelectionReport, publicBenchmarkSystemPrompt, publicDirectAnalystDefinition, publicRlmAnalystDefinition, readAnalystBenchmarkArtifact, readAnalystInstructionsOverride, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, renderUpstreamFindings, resolveTraceAnalystLimits, rlmEngineLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
+export { AGENT_RX_UPSTREAM_REVISION, ANALYST_BENCHMARK_COST_LEDGER_FILE, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, type AgentRxBenchmarkCaseOptions, type AgentRxCalibrationRunnerSummary, type AgentRxCalibrationSummary, type AgentRxFailure, type AgentRxPrediction, type AgentRxPredictionReport, type AgentRxRow, type Analyst, type AnalystBenchmarkArtifact, type AnalystBenchmarkCase, type AnalystBenchmarkCommandConfig, type AnalystBenchmarkCommandDependencies, type AnalystBenchmarkDatasetRef, type AnalystBenchmarkDescriptor, type AnalystBenchmarkError, type AnalystBenchmarkLabelState, type AnalystBenchmarkLocalRunReceipt, type AnalystBenchmarkObservation, type AnalystBenchmarkOutput, type AnalystBenchmarkProgressRow, type AnalystBenchmarkProvenance, type AnalystBenchmarkResult, type AnalystBenchmarkRunIdentity, type AnalystBenchmarkRunManifest, type AnalystBenchmarkRunner, type AnalystBenchmarkSummary, type AnalystBudgetDeclaration, type AnalystComparisonMetric, type AnalystContext, type AnalystCost, type AnalystDefinition, type AnalystDefinitionAsymmetry, type AnalystDefinitionAsymmetryReport, type AnalystEvidenceBinding, type AnalystEvidenceExpectation, type AnalystEvidenceResolution, type AnalystEvidenceResolutionError, type AnalystEvidenceResolver, AnalystExpressivenessError, type AnalystFinding, type AnalystFindingScore, type AnalystHooks, type AnalystInputKind, type AnalystInstructionsOverride, type AnalystIssueExpectation, type AnalystLatencyDistribution, type AnalystMetricComparison, type AnalystProfileFragment, AnalystRegistry, type AnalystRegistryOptions, type AnalystRepairDeclaration, type AnalystRequirements, type AnalystRowExpansion, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystRunnerComparison, type AnalystSeverity, type AnalystTransportBinding, type AnalystUsageReceipt, type BehavioralAnalystOptions, type BudgetPolicy, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTransport, type ChunkedEvidenceBinding, type CodeTraceBenchCaseOptions, type CodeTraceBenchLabelOptions, type CodeTraceBenchLabelSet, type CodeTraceBenchRow, type CodeTraceBlockDiagnostics, type CodeTraceCalibrationRunnerSummary, type CodeTraceCalibrationSummary, type CodeTraceFailureBlock, type CodeTraceStageAnnotation, type CodeTracerLabelGroup, type CodeTracerPredictionAdapterOptions, type CodeTracerPredictions, type CodeTracerStepLabel, ControlIntegrityAnalyst, type CreateChatClientOpts, type CreateTraceAnalystOptions, type CustomTransportOpts, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, DEFAULT_TRACE_ANALYST_KINDS, type DecodedReply, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DspyRlmTraceEngineOptions, type EvidenceProjection, type EvidenceRef, type ExactAnalystBudgetPolicy, type ExactAnalystBudgetSnapshot, type ExactAnalystExecutionPlanSnapshot, type ExactAnalystRunCompletion, type ExactAnalystRunEvent, ExactAnalystRunExecutionError, type ExactAnalystRunPolicySnapshot, type ExactAnalystRunResult, type ExactAnalystRunSummary, type ExactAnalystSnapshot, type ExactCapableAnalyst, type ExactExecutionComponentIdentity, type ExactExecutionComponentSnapshot, type ExactRegistryRunOpts, type ExecutionProbe, type ExecutionProbeOutcome, type ExecutionProbeRequest, type ExpandRowsArgs, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type InlineEvidenceBinding, type JudgeAdapterOpts, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, type MockTransportOpts, type PersistedFinding, type PreparedPublicAnalystBenchmark, type PrimeBenchmarkRunnerOptions, type PrimeBridgeTransport, type PrimeBridgeTransportRequest, type PrimeBridgeTransportResult, type PrimeCodeTraceDefinitionArgs, type PrimeExchangeOptions, type PrimeExchangeOutcome, type PrimeFailure, type PrimeProjectionDelivery, type PrimeProjectionOutcome, type PrimeProjectionSource, type PrimePromptSpec, type PrimeProtocolIdentity, type PrimeRawUsage, type PrimeRejectedRow, type PrimeRepairPromptSpec, type PrimeRepairState, type PrimeReplyContract, type PrimeRowDecoded, type PrimeTurnRecord, type ProposalFinding, type ProposalFindingOrigin, type PublicAnalystBenchmarkDataset, type PublicAnalystBenchmarkModelConfig, type PublicAnalystBenchmarkModelOwner, type PublicAnalystBenchmarkModelSettings, type PublicBenchmarkDistributions, type PublicBenchmarkModelPrediction, type PublicBenchmarkSelectionReport, type PublicBenchmarkValueDistribution, type PublicDirectDefinitionArgs, type PublicRlmDefinitionArgs, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type ReplVariableConsensusPort, type ReplVariableEvidenceBinding, type ReplyContract, type ReplyEnvelope, type ReplyRowDecoded, type ReplyRowRejection, type RunAnalystBenchmarkOptions, type RunCriticAdapterOpts, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifierAdapterOpts, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystDefinitionAsymmetries, analystDefinitionProtocolSha256, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, assertProposalFindings, behavioralAnalyst, bindAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, compareAnalystRunners, computeFindingId, createChatClient, createDspyRlmTraceEngine, createJudgeAdapter, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalyst, createVerifierAdapter, decodeReplyRows, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingSubjectGrammarPromptFor, isProposalFinding, loadCodeTraceVerificationArtifacts, loadPublicBenchmarkRows, makeFinding, makeProposalFinding, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizeAgentRxCategory, normalizeBenchmarkLabel, normalizePrimeUsage, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, primeAnalystProtocolSha256, primeCodeTraceAnalystDefinition, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkRlmInstructions, publicBenchmarkSelectionReport, publicBenchmarkSystemPrompt, publicDirectAnalystDefinition, publicRlmAnalystDefinition, readAnalystBenchmarkArtifact, readAnalystInstructionsOverride, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, resolveTraceAnalystLimits, rlmEngineLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
 //# sourceMappingURL=index.d.ts.map

package/dist/analyst/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/run-critic.ts","../../src/analyst/adapters.ts","../../src/analyst/benchmark-agentrx-calibration.ts","../../src/analyst/benchmark-dataset-types.ts","../../src/analyst/benchmark-dataset-agentrx.ts","../../src/analyst/benchmark-dataset-codetrace.ts","../../src/analyst/benchmark-dataset-utils.ts","../../src/analyst/benchmark-verification-outcome.ts","../../src/analyst/benchmark-verification-artifacts.ts","../../src/analyst/benchmark-public-types.ts","../../src/analyst/benchmark-public-adapters.ts","../../src/analyst/benchmark-public-data.ts","../../src/analyst/reply-contract.ts","../../src/analyst/definition.ts","../../src/analyst/benchmark-public-prompt.ts","../../src/analyst/benchmark-public-model.ts","../../src/analyst/benchmark-public-rlm.ts","../../src/analyst/benchmark-runner-prime.ts","../../src/analyst/benchmark-comparison.ts","../../src/analyst/benchmark-public-calibration.ts","../../src/analyst/benchmark-command-artifact.ts","../../src/analyst/benchmark-command-result.ts","../../src/analyst/benchmark-command.ts","../../src/analyst/benchmark-implementation.ts","../../src/analyst/benchmark-instructions-override.ts","../../src/analyst/benchmark-report.ts","../../src/analyst/benchmark-summary.ts","../../src/analyst/bind.ts","../../src/analyst/define.ts","../../src/analyst/kinds/skill-usage.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/prime-protocol.ts","../../src/analyst/proposal-findings.ts"],"mappings":"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;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;iBAGK,8BACd,QAAQ,yBACP;iBAca,mCAAmC,SAAS;;;UCpC3C;EACf;EACA;EACA;IACE,SAAS;IACT;IACA;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D,uBAAuB;IACvB,0BAA0B;IAC1B;MACE;MACA;MACA;MACA,QAAQ;;IAEV;MACE;MACA;;MAEA;MACA;;MAEA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,UAAU;MACV;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;MAEF;MACA;MACA;;MAEA;MACA;MACA;;;EAGJ,QAAQ;EACR,aAAa;EACb,uBAAuB;EACvB,qBAAqB;;UAGN;EACf;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa;EACf;IACE,SAAS;IACT;IACA;IACA;MACE;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,SAAS;MACT;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;;IAGJ;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D;IACA;;;UAIa;EACf;EACA;EACA;EACA;EACA,UAAU;;UAGK;EACf;EACA;EACA;EACA;IACE;IACA;IACA;IACA;;IAEA;;EAEF;EACA;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;;UAIa;EACf;EACA;EACA;EACA,aAAa;EACb;;cAGW;cACA;cACA;cACA;;;iBC5KS,6BACpB,eACC,QAAQ;;;UCuEM;EACf,uBACE,SAAS,+BACT,QAAQ,wCACL,uBAAuB;EAC5B,2BACE,mBACA;IACE;IACA,aAAa,SAAS,OAAO;QAE5B,QAAQ;;;;;;;;;KAUH;;UAGK;EACf;EACA;;UAGe;EACf,SAAS;EACT,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;EACA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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/run-critic.ts","../../src/analyst/adapters.ts","../../src/analyst/benchmark-agentrx-calibration.ts","../../src/analyst/benchmark-dataset-types.ts","../../src/analyst/benchmark-dataset-agentrx.ts","../../src/analyst/benchmark-dataset-codetrace.ts","../../src/analyst/benchmark-dataset-utils.ts","../../src/analyst/benchmark-verification-outcome.ts","../../src/analyst/benchmark-verification-artifacts.ts","../../src/analyst/benchmark-public-types.ts","../../src/analyst/benchmark-public-adapters.ts","../../src/analyst/benchmark-public-data.ts","../../src/analyst/reply-contract.ts","../../src/analyst/definition.ts","../../src/analyst/benchmark-public-prompt.ts","../../src/analyst/benchmark-public-model.ts","../../src/analyst/benchmark-public-rlm.ts","../../src/analyst/benchmark-runner-prime.ts","../../src/analyst/benchmark-comparison.ts","../../src/analyst/benchmark-public-calibration.ts","../../src/analyst/benchmark-command-artifact.ts","../../src/analyst/benchmark-command-result.ts","../../src/analyst/benchmark-command.ts","../../src/analyst/benchmark-implementation.ts","../../src/analyst/benchmark-instructions-override.ts","../../src/analyst/benchmark-report.ts","../../src/analyst/benchmark-summary.ts","../../src/analyst/bind.ts","../../src/analyst/define.ts","../../src/analyst/kinds/skill-usage.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/prime-protocol.ts","../../src/analyst/proposal-findings.ts"],"mappings":"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ACf;EACA;EACA,SAAS;;iBAGK,8BACd,QAAQ,yBACP;iBAca,mCAAmC,SAAS;;;UCpC3C;EACf;EACA;EACA;IACE,SAAS;IACT;IACA;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D,uBAAuB;IACvB,0BAA0B;IAC1B;MACE;MACA;MACA;MACA,QAAQ;;IAEV;MACE;MACA;;MAEA;MACA;;MAEA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,UAAU;MACV;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;MAEF;MACA;MACA;;MAEA;MACA;MACA;;;EAGJ,QAAQ;EACR,aAAa;EACb,uBAAuB;EACvB,qBAAqB;;UAGN;EACf;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa;EACf;IACE,SAAS;IACT;IACA;IACA;MACE;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,SAAS;MACT;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;;IAGJ;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D;IACA;;;UAIa;EACf;EACA;EACA;EACA;EACA,UAAU;;UAGK;EACf;EACA;EACA;EACA;IACE;IACA;IACA;IACA;;IAEA;;EAEF;EACA;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;;UAIa;EACf;EACA;EACA;EACA,aAAa;EACb;;cAGW;cACA;cACA;cACA;;;iBC5KS,6BACpB,eACC,QAAQ;;;UCuEM;EACf,uBACE,SAAS,+BACT,QAAQ,wCACL,uBAAuB;EAC5B,2BACE,mBACA;IACE;IACA,aAAa,SAAS,OAAO;QAE5B,QAAQ;;;;;;;;;KAUH;;UAGK;EACf;EACA;;UAGe;EACf,SAAS;EACT,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA,QAAQ;EACR;EACA;;iBAKoB,2BACpB,yBACA,MAAK,OAAO,YACZ,eAAc,sCACb;;;cCzJU;cAEA;cAEA;cAOA;cAYA;cAGA;cAGA;cA8GA;iBAGG;iBAIA;;;;iBCzIA,oCAAoC,eAAe;;iBAQnD,gCAAgC,eAAe;;;;;;;;;;;iBAyB/C,+BACd,SAAS,+BACT,WAAW,KAAK;;;iBCzCF,+BACd,QAAQ,wBACR,uBAAsB;;;iBCER,gCACd,kBACA,uBAAuB,gCACtB;;;;KCgBS;;WAGG;WACA;WACA;WACA,YAAY;WACZ,UAAU;;;WAIV;WACA,QAAQ;;;;;;iBAOP,YAAY,MAAM,aAAa,QAC7C,YAAY,kBAAkB,MAAM,aAAa,SACjD,YAAY,0BACX,uBAAuB;;;;;;;;;;iBCpCV,mBAAmB,YAAY,yBAAyB;UAkBvD;EACf;EACA;EACA;EACA,MAAM;EACN,SAAS,QAAQ;;UAGF,wCAAwC;;EAEvD,iBAAiB,SAAS;;;iBAIZ,oBACd,SAAS,kCACR,oBAAoB;iBACP,oBACd,SAAS,6BACR,QAAQ;;;KCpBC;;UAGK;EACf;EACA,MAAM;;EAEN;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA,SAAS;;UAGM;;EAEf;;EAEA;IAAc;IAAc,MAAM;;;EAElC;;;EAGA,kBAAkB;;EAElB;;;iBA2Ec,sBAAsB,QAAQ,uBAAuB;;iBAiHrD,uBACd,QAAQ,kBACR,qBACC;cA2HG,6BAA6B,oBAAoB;WAC5C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;aACA;;EAGI,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB,QAAQ;;cAS1D,qBAAmB;;;;;;;;;;;;;;;iBC5YhB,gBAAgB;;;;;iBAgBhB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCKf,gBAAgB,QAAQ,gBAAgB;KAExC,mBAAmB,QAAQ,cAAc;UAIpC;EACf;;EAEA;EACA;;EAEA;EACA;;EAEA;;iBAGc,iBAAiB,MAAM;UAatB;EACf;EACA;EACA;;;iBAIc,uBAAuB,MAAM;;;;;;;;;;iBAuB7B,uBAAuB,eAAe;;iBAkBtC,iBACd,QAAQ,gCACR;;;;;;UAyBe;;;;;;EAMf;;EAEA;;EAEA;;;;;;;EAOA;;iBAGc,sBAAsB;;iBAKtB,oBAAoB,eAAe;;;;;;iBAgBnC,mBAAmB,GAAG,eAAe,GAAG,gBAAgB;;;;;;;;;;;;;iBA6BxD,kCACd,OAAO,eACP,SAAS,qBACR;;;;;;;;KAqCS;EAEN;EACA;;EAEA;EAAqB;EAAiB;EAAgB;;EACtD;EAAiB;EAAiB;;UAEvB;EACf;;EAEA;;;UAIe;EACf;EACA,OAAO;;EAEP;;UAGe;EACf;EACA;;KAGU,qBAAqB;EAE3B;;EAEA;EACA,MAAM;EACN,UAAU;;EAEV;;EAEA;EACA,OAAO;EACP,OAAO;EACP,QAAQ;EACR;;EAGA;EACA,SAAS;EACT,OAAO;EACP,OAAO;EACP,QAAQ;;EAER;;UAGW,qBAAqB;EACpC,UAAU,mBAAmB;EAC7B;EACA,WAAW;;EAEX;EACA;;EAEA;;EAEA;EACA,SAAS;;;;;;;iBAQW,iBAAiB,MACrC,SAAS,qBAAqB,QAC7B,QAAQ,qBAAqB;;;;;;UAyLf,sBAAsB;;EAErC,QAAQ,iBAAiB;;EAEzB,UAAU,iBAAiB;;EAE3B;;UAGe;EACf;EACA;EACA;;KAGU,uBAAuB;EAE7B;EACA,gBAAgB;EAChB;EACA,UAAU;;EAEV;EAAW;EAAgB;;;;;;;;;iBASX,uBAAuB,OAC3C,QAAQ,sBAAsB,QAC9B;EAAU;IACT,QAAQ,uBAAuB;UA8BjB;EACf;EACA;EACA;EACA;;EAEA,QAAQ,SAAS;;;;;;;;;;;;iBAaH,oBAAoB,UAAU;;;;iBC/iB9B,kBAAkB,mBAAmB,WAAW;;;;;;iBAShD,uBACd,mBACA,mBACC,cAAc"}