@tangle-network/agent-eval 0.196.0 → 0.198.0

package/CHANGELOG.md

@@ -6,6 +6,69 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ## Unreleased
 
+## [0.198.0] — 2026-09-27
+
+### Added
+
+- Search lenses (`/search`, search-tree-design §12): `tree`, `operatorYield`, `front` and `taskMatrix`, each a pure function of `SearchState` returning JSON for a view plus one named signal a `SearchPolicy` can read. `agent-eval search show` gains `--tree`/`--operator-yield`/`--front`/`--task-matrix` to print each lens's text form.
+  `operatorYield` groups edges by operator and reports outcome counts and improvement-per-known-dollar yield (via `searchPosterior`, excluding any node with an unknown-cost cell rather than flooring it). `front` is the Pareto frontier over score and known cost, reusing the existing `paretoFrontier` primitive, with room for caller-declared extra axes. `taskMatrix` clusters nodes and units by single-linkage clustering with a data-derived cutoff and reports each unit cluster's specialist gain (best node's mean minus the cluster mean).
+  `incumbentWithOperatorBandit({ seed, fixedWeights? })` (`/campaign`) is a hill-climb `SearchPolicy` that draws its expansion operator from `operatorYield`'s signal once an operator has 6 or more measured outcomes (falling back to a fixed prior per operator until then, and adding a measured yield to that same prior rather than replacing it, so the two stay on comparable scales); `incumbent` itself is unchanged.
+  `scripts/generate-synthetic-search-ledger.ts` and `scripts/import-vb-climb.ts` (the latter through the GEPA importer) produce real ledgers these lenses are proved against; `scripts/prove-operator-bandit.mts` is a real-run (no-mock) proof of the bandit's draw distribution against the lens's own signal.
+- `metaSearch(searches)` (`/search`) treats each search as a node whose genome is its policy configuration and whose score is its claim's held-out lift per known dollar; an unscored search carries its reason, never 0. Searches form a forest by derivation and containment.
+  `runNestedSearch` runs an outer search whose cells are inner searches on the same kernel; `scripts/search-meta-sim.ts` runs one on the simulator, and `agent-eval search show --meta [--json]` prints the lens.
+- `editCredit(state, { readArtifact })` (`/search`) cuts each lineage edge's parent-to-child diff into paragraph edits with stable ids and credits an edit on the clean lineage steps where it alone changed, pairing the carrying side against the lacking side on shared units through `pairedDeltaTest`. It reports linked edits, interacting pairs and inline skill candidates, with the signal `reusableHunks`; `agent-eval search show --edit-credit [--json]` prints it.
+- `landscape(state, embedding)` (`/search`) places nodes by landmark classical MDS of a pluggable distance, kriges the improvement over the root with each node's own noise, counts basins by persistence on the 6-nearest-neighbour graph, and signals `plateau`. `draftOnPlateau(base, { window, below })` drafts from the root when the plateau score is below one standard error.
+  `skillManifold(state, k?, options?)` (`/search`) factors the node x unit score matrix (a two-parameter item-response model when every cell is 0 or 1) and signals the unit whose next cell best separates the leaders; `skillCalibration` keeps its loadings and `asha({ extend: nextUnitExtension(calibration) })` fills each opened rung with them (off by default).
+  `agent-eval search show --landscape --skill-manifold` prints both; `scripts/search-sim.ts plateau|adaptive|lens-null` measures them.
+- `aide({ drafts, debugProbability, maxDebugDepth, stallAfter })` (`/campaign`) is AIDE's search policy with three changes for noisy scores ([search ledger](./docs/search-ledger.md#run-a-search-the-kernel)).
+  It drafts whole alternatives from the root until `drafts` nodes (default 5) were drafted.
+  Then, with probability `debugProbability` (0.5), it debugs a buggy leaf: a node whose final cells outside the test split `failed` at least half the time, so a defect such as a crash or a broken build, never an `errored` environment fault or a low score.
+  Otherwise it improves a parent drawn by Thompson sampling over each node's posterior from `searchPosterior`, not AIDE's argmax, so a node measured on few units draws from a wide posterior.
+  After `stallAfter` (4) improve children in a row leave a lineage's best posterior mean unraised, the next improve forks from the node with the best posterior mean.
+- `beam({ width })` (`/campaign`) expands the top `width` nodes by posterior mean in turn; a node an allocator has only screened waits for its rank before it enters the beam.
+- `SearchPolicyView` gains `nodes()`, every node's lineage, status and defect count, and `posterior`, the search's `searchPosterior` on the policy split, computed once per ledger state.
+  Each edge records the rule and evidence that chose its parent (`aide:draft`, `aide:debug`, `aide:thompson`, `aide:uniform-draw`, `aide:stall-fork`, `beam(width=k)`).
+- `scripts/search-sim.ts compare --arms incumbent+uniform,aide+asha,...` runs one search per seed under each `policy+allocation` arm, at equal cells with `--max-cells`, and pairs every arm with the first by seed.
+  `--deep-gain X` plants a gain at depth 3 of one lineage behind neutral path nodes, and `--defect-rate X` makes a share of children fail every cell as a defect.
+  Over 200 seeded searches at 600 cells with a +0.10 gain planted at depth 3 of 24 selection units, `aide` + `asha` kept the planted node in 34 (17.0 %, Wilson 95 % [12.4 %, 22.8 %]) and `incumbent` + `uniform` in 11 (5.5 % [3.1 %, 9.6 %]); 27 seeds found it only under `aide` + `asha` and 4 only under `incumbent` + `uniform` (sign test p = 3.4e-5).
+
+### Changed
+
+- The kernel refuses an expansion without a parent, or with a parent whose screen has not finished.
+- `SearchPolicyView.operatorWeights` is computed when a policy first reads it, not for every view.
+
+### Fixed
+
+- A restarted kernel keeps a node an allocator advanced among the screened nodes while its rung cells run; before, `aide` and `beam` could not choose it as a parent until those cells finished, where the uninterrupted search could.
+- A restarted kernel no longer re-admits a child the divergence rule decided `invalid` when it finishes that child's recorded proposal.
+  It had marked the child screened, so after a restart an invalid node counted among `aide`'s Thompson candidates and on `crowdedFrontierParent`'s frontier, and `incumbent` could keep it as leader.
+- `scripts/search-sim.ts`: a draft honors `--null`, so a null search stays null, and is defective at `--defect-rate`; under `--deep-gain` a draft is one more child of the root, whose tree holds the plant.
+  Every simulated run also re-derives each proposal's parents, operator and selection evidence from the ledger before it, and `kill-resume` requires the resumed search to equal the uninterrupted one only for a hill climb under `uniform`.
+
+### Removed
+
+- **Breaking:** `thompsonCurriculum`, `ThompsonCurriculumOptions`, `observationsFromRunRecords` and `CellObservation.pass` (`/rl`).
+  `thompsonCurriculum` sharpened pass rates near a fixed 0.5 threshold, and only its own test called it.
+  Migration: choose which search node to expand with `aide`, which draws parents by Thompson sampling over node posteriors; allocate scenario samples with `varianceBasedCurriculum`, which reads only `variantId`, `scenarioId` and `score`.
+
+## [0.197.0] — 2026-09-26
+
+### Added
+
+- `campaignCellSearchResult(cell, { execution, lane })` (`/campaign`) maps one `runCampaign` cell to the result `cell-settled` records: `passed` with the composite and each judge's score, else a non-retryable `errored` outcome; its tokens and cost, an uncaptured cost kept as a lower bound; the model the cell resolved. `runOptimization` uses it, and so can an executor outside this package, such as agent-runtime's `searchMethod`.
+  `searchModelIdentity(model, provider)` is the snapshot-or-alias rule it applies; `searchReceiptAccounting(receipts)` and `searchProposalExecution(receipts, provider, source)` are what `operation-recorded` records for a proposal's cost receipts.
+
+### Changed
+
+- `gepaOptimizationMethod({ searchLedger })` records every recipe's search. A composed recipe reports no candidate population, so its evaluated candidates enter with `unknown` edges and GEPA's returned best is `selected`, as SkillOpt's are; before, such a recipe returned no `searchHistory`, and a comparison under `searchHistoryPolicy: 'require-complete'` refused it. `recordGepaSearch` takes `population: null` with `selected` for this case.
+
+### Fixed
+
+- `parseJevRequest` refuses a null `state` or a null score level with a `TypeError`, before any paid call ([Jev](./docs/jev.md)).
+  TypeSafe's published schema (`https://api.typesafe.ai/openapi.json`) requires both to be text, a JSON object or a JSON array; on 2026-09-26 it answered 422 for each, and the Tangle Router reported that as 503 `provider_response_invalid`.
+  `JevState` no longer includes `null`; the new `JevDescription` (`JevState | null`) types instructions and choice or noul descriptions, which TypeSafe accepts as null.
+  `parseJevQuestions` validates named questions without a state; `jevJudge` uses it instead of a placeholder null state.
+
 ## [0.196.0] — 2026-09-26
 
 ### Added

package/dist/active-curriculum-B_Lc9kfO.js

@@ -0,0 +1,61 @@
+//#region src/rl/active-curriculum.ts
+/**
+* Variance-proportional allocation. For each cell, estimate variance from
+* past observations + a prior, then allocate the budget proportional to
+* (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule
+* (Neyman 1934) that balances "explore noisy cells" with "explore
+* under-sampled cells."
+*/
+function varianceBasedCurriculum(observations, candidateCells, opts) {
+	const variancePrior = opts.variancePrior ?? .05;
+	const floor = opts.floorPerCell ?? 1;
+	const budget = opts.budget;
+	const grouped = /* @__PURE__ */ new Map();
+	for (const o of observations) {
+		const k = `${o.variantId}::${o.scenarioId}`;
+		const arr = grouped.get(k) ?? [];
+		arr.push(o.score);
+		grouped.set(k, arr);
+	}
+	const cellStats = candidateCells.map((c) => {
+		const k = `${c.variantId}::${c.scenarioId}`;
+		const samples = grouped.get(k) ?? [];
+		const n = samples.length;
+		const mean = n === 0 ? .5 : samples.reduce((s, v) => s + v, 0) / n;
+		const variance = n < 2 ? variancePrior : samples.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1) + variancePrior;
+		const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n));
+		return {
+			variantId: c.variantId,
+			scenarioId: c.scenarioId,
+			n,
+			mean,
+			variance,
+			weight
+		};
+	});
+	const floorTotal = floor * cellStats.length;
+	if (floorTotal >= budget) {
+		const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)));
+		return cellStats.map((c) => ({
+			variantId: c.variantId,
+			scenarioId: c.scenarioId,
+			count: each,
+			reason: `floor allocation (budget tight; n=${c.n})`
+		}));
+	}
+	const remaining = budget - floorTotal;
+	const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0);
+	return cellStats.map((c) => {
+		const proportional = totalWeight === 0 ? 0 : Math.round(c.weight / totalWeight * remaining);
+		return {
+			variantId: c.variantId,
+			scenarioId: c.scenarioId,
+			count: floor + proportional,
+			reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`
+		};
+	});
+}
+//#endregion
+export { varianceBasedCurriculum as t };
+
+//# sourceMappingURL=active-curriculum-B_Lc9kfO.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"active-curriculum-B_Lc9kfO.js","names":[],"sources":["../src/rl/active-curriculum.ts"],"sourcesContent":["/**\n * Adaptive curriculum: active scenario selection by variance.\n *\n * Fixed scenario sets waste sample budget on cells whose outcome is already\n * settled. `varianceBasedCurriculum` scores each (variant, scenario) cell by\n * the empirical variance of past observations and allocates the next round's\n * budget toward the noisy and under-sampled cells. The output is a next-round\n * allocation, a list of (variant, scenario, count) triples, which the\n * consumer runs and feeds back.\n *\n * Choosing which search node to expand is not a curriculum; it belongs to the\n * search policy (`aide` draws parents by Thompson sampling over each node's\n * posterior, in `campaign/search-policy.ts`). Scenario generation belongs to\n * the adversarial primitive.\n */\n\nexport interface CellObservation {\n  variantId: string\n  scenarioId: string\n  /** Observed score in [0, 1]. */\n  score: number\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"],"mappings":";;;;;;;;AAuDA,SAAgB,wBACd,cACA,gBACA,MACwB;CACxB,MAAM,gBAAgB,KAAK,iBAAiB;CAC5C,MAAM,QAAQ,KAAK,gBAAgB;CACnC,MAAM,SAAS,KAAK;CAEpB,MAAM,0BAAU,IAAI,IAAsB;CAC1C,KAAK,MAAM,KAAK,cAAc;EAC5B,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,MAAM,QAAQ,IAAI,CAAC,KAAK,CAAC;EAC/B,IAAI,KAAK,EAAE,KAAK;EAChB,QAAQ,IAAI,GAAG,GAAG;CACpB;CAEA,MAAM,YAAY,eAAe,KAAK,MAAM;EAC1C,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,UAAU,QAAQ,IAAI,CAAC,KAAK,CAAC;EACnC,MAAM,IAAI,QAAQ;EAClB,MAAM,OAAO,MAAM,IAAI,KAAM,QAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;EAClE,MAAM,WACJ,IAAI,IACA,gBACA,QAAQ,QAAQ,GAAG,MAAM,KAAK,IAAI,SAAS,GAAG,CAAC,KAAK,IAAI,KAAK;EAGnE,MAAM,SAAS,KAAK,KAAK,QAAQ,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,CAAC,CAAC;EACjE,OAAO;GAAE,WAAW,EAAE;GAAW,YAAY,EAAE;GAAY;GAAG;GAAM;GAAU;EAAO;CACvF,CAAC;CAGD,MAAM,aAAa,QAAQ,UAAU;CACrC,IAAI,cAAc,QAAQ;EACxB,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,SAAS,KAAK,IAAI,GAAG,UAAU,MAAM,CAAC,CAAC;EAC3E,OAAO,UAAU,KAAK,OAAO;GAC3B,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO;GACP,QAAQ,qCAAqC,EAAE,EAAE;EACnD,EAAE;CACJ;CACA,MAAM,YAAY,SAAS;CAC3B,MAAM,cAAc,UAAU,QAAQ,GAAG,MAAM,IAAI,EAAE,QAAQ,CAAC;CAC9D,OAAO,UAAU,KAAK,MAAM;EAC1B,MAAM,eAAe,gBAAgB,IAAI,IAAI,KAAK,MAAO,EAAE,SAAS,cAAe,SAAS;EAC5F,OAAO;GACL,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO,QAAQ;GACf,QAAQ,YAAY,EAAE,SAAS,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,QAAQ,CAAC,EAAE;EACjF;CACF,CAAC;AACH"}

package/dist/adapters/http.d.ts

@@ -1,6 +1,6 @@
 import { m as CostReceipt } from "../cost-ledger-DbQdN3nO.js";
-import { R as Scenario, d as DispatchContext, f as DispatchFn } from "../types-B2673PBj.js";
-import "../index-CpCIXObe.js";
+import { R as Scenario, d as DispatchContext, f as DispatchFn } from "../types-EBUav9Bu.js";
+import "../index-D-tI1vgf.js";
 //#region src/adapters/http.d.ts
 interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
   /** Static endpoint URL. Mutually exclusive with `resolveUrl`. */

package/dist/analyst/index.d.ts

@@ -4,10 +4,10 @@ import { A as createChatClient, C as ChatResponse, D as MockTransportOpts, E as
 import { A as runAnalystBenchmark, C as AnalystEvidenceResolutionError, D as AnalystLatencyDistribution, E as AnalystIssueExpectation, M as scoreAnalystFindings, O as RunAnalystBenchmarkOptions, S as AnalystEvidenceResolution, T as AnalystFindingScore, V as ExternalOptimizerModelCall, W as ExternalOptimizerModelExecutionObservation, _ as AnalystBenchmarkProvenance, b as AnalystBenchmarkSummary, d as AnalystBenchmarkDatasetRef, f as AnalystBenchmarkDescriptor, g as AnalystBenchmarkOutput, h as AnalystBenchmarkObservation, j as traceStoreEvidenceResolver, k as registryBenchmarkRunner, m as AnalystBenchmarkLabelState, p as AnalystBenchmarkError, q as ExternalOptimizerRunnerCommand, t as AgentProfile, u as AnalystBenchmarkCase, v as AnalystBenchmarkResult, w as AnalystEvidenceResolver, x as AnalystEvidenceExpectation, y as AnalystBenchmarkRunner } from "../agent-profile-DDfIjdyS.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-KGxBWH4b.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-Bu3lNole.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-D2csUBBQ.js";
-import { a as TraceAnalystLimits, c as RawAnalystEvidence, d as evidenceRefsFromRawFinding, f as parseRawFinding, i as TraceAnalysisEngineResult, l as RawAnalystFinding, n as TraceAnalysisEngine, o as resolveTraceAnalystLimits, r as TraceAnalysisEngineRequest, s as RAW_FINDING_SCHEMA_PROMPT, t as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, u as RawAnalystFindingSchema } from "../engine-De2hfuiQ.js";
-import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-groups-B4JVrH3g.js";
-import { A as SemanticConceptJudgeInput, C as DspyRlmTraceEngineOptions, E as createChatTraceEngine, S as renderFindingSubject, T as ChatTraceEngineOptions, _ 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, 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 FindingSubjectKind, w as createDspyRlmTraceEngine, x as parseFindingSubject, y as KIND_EXPECTED_SUBJECTS } from "../index-kKECJfib.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-oK9hHfX_.js";
+import { a as TraceAnalystLimits, c as RawAnalystEvidence, d as evidenceRefsFromRawFinding, f as parseRawFinding, i as TraceAnalysisEngineResult, l as RawAnalystFinding, n as TraceAnalysisEngine, o as resolveTraceAnalystLimits, r as TraceAnalysisEngineRequest, s as RAW_FINDING_SCHEMA_PROMPT, t as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, u as RawAnalystFindingSchema } from "../engine-Dc996kAg.js";
+import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-groups-DVJAR1GE.js";
+import { A as SemanticConceptJudgeInput, C as DspyRlmTraceEngineOptions, E as createChatTraceEngine, S as renderFindingSubject, T as ChatTraceEngineOptions, _ 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, 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 FindingSubjectKind, w as createDspyRlmTraceEngine, x as parseFindingSubject, y as KIND_EXPECTED_SUBJECTS } from "../index-lbwvO9vJ.js";
 import { A as ReplyRowDecoded, C as primeProtocolSha256, D as DecodedReply, E as runPrimeExchange, M as decodeReplyRows, O as ReplyContract, S as normalizePrimeUsage, T as projectPrimeTrajectory, _ as buildPrimePrompt, a as PrimeProjectionOutcome, b as extractPrimeJsonObject, c as PrimeProtocolIdentity, d as PrimeRepairPromptSpec, f as PrimeRepairState, g as analystUsageReceiptFromPrimeUsage, h as PrimeTurnRecord, i as PrimeProjectionDelivery, j as ReplyRowRejection, k as ReplyEnvelope, l as PrimeRawUsage, m as PrimeRowDecoded, n as PrimeExchangeOutcome, o as PrimeProjectionSource, p as PrimeReplyContract, r as PrimeFailure, s as PrimePromptSpec, t as PrimeExchangeOptions, u as PrimeRejectedRow, v as buildPrimeRepairPrompt, w as primeReplyDefect, x as mergePrimeRawUsage, y as emptyPrimeRawUsage } from "../prime-protocol-T0i6xcAs.js";
 import { i as nodeHttpPrimeBridgeTransport, n as PrimeBridgeTransportRequest, r as PrimeBridgeTransportResult, t as PrimeBridgeTransport } from "../prime-bridge-transport-6feEglLf.js";
 import { z } from "zod";
@@ -1181,7 +1181,7 @@ declare function runAnalystBenchmarkCommand(argv: readonly string[], env?: NodeJ
 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 = "437e1321f760652a075cf63fa53104f0baa627cffacb12d525eed54690e7f8ca";
+declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "6a4ac13d561bde646277270c5861b6f1021ae91d582d6eff2047af6e52f2dce9";
 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[];

package/dist/analyst/index.js

@@ -4,11 +4,11 @@ import { B as FINDING_SUBJECT_SYNTAX, F as parseRawFinding, G as DEFAULT_TRACE_A
 import { i as validateUsageSettlementTimeout, n as settleUsageReceiptFromCostLedger } from "../usage-receipt-Cx3xNeyB.js";
 import { a as KNOWLEDGE_POISONING_KIND_SPEC, c as FAILURE_MODE_KIND_SPEC, d as emitControlIntegrityFindings, f as behavioralAnalyst, i as DEFAULT_TRACE_ANALYST_KINDS, l as CONTROL_INTEGRITY_ANALYST, n as AnalystRegistry, o as KNOWLEDGE_GAP_KIND_SPEC, p as deriveEfficiencyFindings, r as ExactAnalystRunExecutionError, s as IMPROVEMENT_KIND_SPEC, t as buildDefaultAnalystRegistry, u as ControlIntegrityAnalyst } from "../default-registry-xMLX160E.js";
 import { i as makeProposalFinding, n as computeFindingId, r as makeFinding } from "../types-CW5b90JH.js";
-import { t as createDspyRlmTraceEngine } from "../dspy-rlm-engine-k_QdEBZo.js";
-import { a as diffFindings, i as defaultIsMaterial, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "../semantic-concept-judge-Bh5lvKGg.js";
+import { t as createDspyRlmTraceEngine } from "../dspy-rlm-engine-B5T43BkZ.js";
+import { a as diffFindings, i as defaultIsMaterial, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "../semantic-concept-judge-2SE_kXGF.js";
 import { t as createChatClient } from "../chat-client-CJORSG_J.js";
 import { a as scoreAnalystFindings, i as summarizeAnalystBenchmarkRunner, n as runAnalystBenchmark, r as traceStoreEvidenceResolver, t as registryBenchmarkRunner } from "../benchmark-BeQJyrRC.js";
-import { $ as ANALYST_BENCHMARK_MANIFEST_FILE, A as readAnalystInstructionsOverride, B as parseVerificationOutcome, C as emptyPublicBenchmarkRunner, D as summarizeCodeTraceCalibration, E as renderCodeTraceCalibrationMarkdown, F as publicBenchmarkRlmInstructions, G as ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, H as ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, I as publicBenchmarkSystemPrompt, J as ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, K as ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, L as DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, M as MAX_INCORRECT_BLOCKS, N as MAX_INCORRECT_BLOCK_STEPS, O as analystInstructionsOverrideFromText, P as publicBenchmarkProtocolSha256, Q as ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, R as appendVerificationArtifactsToOtlp, S as adaptPublicBenchmarkFindings, T as readAnalystBenchmarkArtifact, U as ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, V as ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, W as ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, X as analystBenchmarkImplementationDigest, Y as analystBenchmarkDependencyLockDigest, Z as ANALYST_BENCHMARK_COST_LEDGER_FILE, _ as publicDirectAnalystDefinition, a as primeCodeTraceAnalystDefinition, at as codeTraceBenchCase, b as analystDefinitionAsymmetries, c as preparePublicAnalystBenchmark, ct as agentRxPredictionsToFindings, d as selectPublicBenchmarkRows, dt as normalizeBenchmarkLabel, et as ANALYST_BENCHMARK_OBSERVATIONS_FILE, f as createPublicBenchmarkRlmRunner, g as createPublicBenchmarkDirectRunner, h as runReplVariableAnalystDefinition, i as primeAnalystProtocolSha256, it as summarizeAgentRxCalibration, j as CODE_TRACE_BENCH_ANALYST_PROMPT, k as effectiveAnalystProtocolSha256, l as publicBenchmarkDistributions, lt as normalizeAgentRxCategory, m as rlmEngineLimits, n as renderAnalystBenchmarkMarkdown, nt as AGENT_RX_UPSTREAM_REVISION, o as runInlineAnalystDefinition, ot as codeTracerPredictionsToFindings, p as publicRlmAnalystDefinition, q as ANALYST_BENCHMARK_IMPLEMENTATION_FILES, r as createPrimeBenchmarkRunner, rt as renderAgentRxCalibrationMarkdown, s as loadPublicBenchmarkRows, st as agentRxBenchmarkCase, t as runAnalystBenchmarkCommand, tt as compareAnalystRunners, u as publicBenchmarkSelectionReport, ut as roundAgentRxStep, v as runChunkedAnalystDefinition, w as expandCodeTraceFailureBlocks, x as analystDefinitionProtocolSha256, y as AnalystExpressivenessError, z as loadCodeTraceVerificationArtifacts } from "../benchmark-command-Bw1he2JM.js";
+import { $ as ANALYST_BENCHMARK_MANIFEST_FILE, A as readAnalystInstructionsOverride, B as parseVerificationOutcome, C as emptyPublicBenchmarkRunner, D as summarizeCodeTraceCalibration, E as renderCodeTraceCalibrationMarkdown, F as publicBenchmarkRlmInstructions, G as ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, H as ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, I as publicBenchmarkSystemPrompt, J as ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, K as ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, L as DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, M as MAX_INCORRECT_BLOCKS, N as MAX_INCORRECT_BLOCK_STEPS, O as analystInstructionsOverrideFromText, P as publicBenchmarkProtocolSha256, Q as ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, R as appendVerificationArtifactsToOtlp, S as adaptPublicBenchmarkFindings, T as readAnalystBenchmarkArtifact, U as ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, V as ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, W as ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, X as analystBenchmarkImplementationDigest, Y as analystBenchmarkDependencyLockDigest, Z as ANALYST_BENCHMARK_COST_LEDGER_FILE, _ as publicDirectAnalystDefinition, a as primeCodeTraceAnalystDefinition, at as codeTraceBenchCase, b as analystDefinitionAsymmetries, c as preparePublicAnalystBenchmark, ct as agentRxPredictionsToFindings, d as selectPublicBenchmarkRows, dt as normalizeBenchmarkLabel, et as ANALYST_BENCHMARK_OBSERVATIONS_FILE, f as createPublicBenchmarkRlmRunner, g as createPublicBenchmarkDirectRunner, h as runReplVariableAnalystDefinition, i as primeAnalystProtocolSha256, it as summarizeAgentRxCalibration, j as CODE_TRACE_BENCH_ANALYST_PROMPT, k as effectiveAnalystProtocolSha256, l as publicBenchmarkDistributions, lt as normalizeAgentRxCategory, m as rlmEngineLimits, n as renderAnalystBenchmarkMarkdown, nt as AGENT_RX_UPSTREAM_REVISION, o as runInlineAnalystDefinition, ot as codeTracerPredictionsToFindings, p as publicRlmAnalystDefinition, q as ANALYST_BENCHMARK_IMPLEMENTATION_FILES, r as createPrimeBenchmarkRunner, rt as renderAgentRxCalibrationMarkdown, s as loadPublicBenchmarkRows, st as agentRxBenchmarkCase, t as runAnalystBenchmarkCommand, tt as compareAnalystRunners, u as publicBenchmarkSelectionReport, ut as roundAgentRxStep, v as runChunkedAnalystDefinition, w as expandCodeTraceFailureBlocks, x as analystDefinitionProtocolSha256, y as AnalystExpressivenessError, z as loadCodeTraceVerificationArtifacts } from "../benchmark-command-D8E5TaPC.js";
 import { a as extractPrimeJsonObject, c as primeProtocolSha256, d as runPrimeExchange, f as decodeReplyRows, i as emptyPrimeRawUsage, l as primeReplyDefect, n as buildPrimePrompt, o as mergePrimeRawUsage, r as buildPrimeRepairPrompt, s as normalizePrimeUsage, t as analystUsageReceiptFromPrimeUsage, u as projectPrimeTrajectory } from "../prime-protocol-DcAK9pC8.js";
 import { t as nodeHttpPrimeBridgeTransport } from "../prime-bridge-transport-Z3cpKGoV.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";

package/dist/{analyze-runs-B6gv7vAT.js → analyze-runs-DFbp2gB8.js}

@@ -1,15 +1,15 @@
 import { a as spearmanR, r as pearsonR } from "./descriptive-1V17A-qa.js";
 import { r as continuousAgreement } from "./judge-calibration-DYmaBtJr.js";
 import { i as pairedCohensDz } from "./effect-sizes-DiH8MGOH.js";
-import { i as requiredPairedSampleSize, r as pairedMde } from "./power-and-mde-BJOpt6pq.js";
-import { r as pairRunRecords } from "./paired-arms-JSDcs2zx.js";
 import { o as pairedTTest, r as pairedBootstrap } from "./paired-tests-C8iCsioC.js";
+import { r as pairRunRecords } from "./paired-arms-DKZFVPt8.js";
+import { i as requiredPairedSampleSize, r as pairedMde } from "./power-and-mde-K_CmO3dc.js";
 import { r as welchsTTest } from "./baseline-BC-eBZ7U.js";
-import { n as aggregatePairedHoldout } from "./statistical-heldout-DANVmyug.js";
+import { n as aggregatePairedHoldout } from "./statistical-heldout-BAFDCo07.js";
 import "./query-DlV0pdx4.js";
 import { r as observedSplitScore } from "./reward-nw2xZGZG.js";
 import { u as validateRunRecord } from "./run-record-BRlM99rX.js";
-import { r as paretoChart } from "./summary-report-BMvou2oZ.js";
+import { r as paretoChart } from "./summary-report-BeYnvddy.js";
 //#region src/contamination-guard.ts
 function checkCanaries(output, scenarios) {
 	const leaks = [];
@@ -982,4 +982,4 @@ function buildRecommendations(ctx) {
 //#endregion
 export { summarizeExecution as n, checkCanaries as r, analyzeRuns as t };
 
-//# sourceMappingURL=analyze-runs-B6gv7vAT.js.map
+//# sourceMappingURL=analyze-runs-DFbp2gB8.js.map