@tangle-network/agent-eval 1.0.21 → 1.0.23

package/dist/{types-BsdcSWnf.d.ts → types-3uX8odDK.d.ts}

@@ -1,5 +1,5 @@
-import { c as RunSplitTag } from "./run-record-D2BFMPGl.js";
-import { R as Scenario, d as DispatchContext } from "./types-ip2D3-Ib.js";
+import { c as RunSplitTag } from "./run-record-pBlhZizT.js";
+import { R as Scenario, d as DispatchContext } from "./types-efIQ03Uo.js";
 type BenchmarkTaskKind = 'retrieval' | 'rag-answer' | 'hallucination' | 'kb-improvement' | 'routing' | 'custom';
 type BenchmarkFamily = 'beir' | 'mteb-retrieval' | 'msmarco' | 'trec-dl' | 'miracl' | 'lotte' | 'bright' | 'crag' | 'hotpotqa' | 'kilt' | 'ragtruth' | 'faithbench' | 'first-party' | 'custom';
 interface BenchmarkDatasetItem<TPayload = unknown> {
@@ -97,4 +97,4 @@ declare const BENCHMARK_SPLIT_SEED = "agent-eval-v1";
  */
 declare function deterministicSplit(itemId: string, seed?: string): RunSplitTag;
 export { BenchmarkFamily as a, BenchmarkSource as c, BenchmarkEvaluation as i, BenchmarkTaskKind as l, BenchmarkAdapter as n, BenchmarkResponder as o, BenchmarkDatasetItem as r, BenchmarkScenario as s, BENCHMARK_SPLIT_SEED as t, deterministicSplit as u };
-//# sourceMappingURL=types-BsdcSWnf.d.ts.map
+//# sourceMappingURL=types-3uX8odDK.d.ts.map

package/dist/{types-BsdcSWnf.d.ts.map → types-3uX8odDK.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-BsdcSWnf.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;;;;EAKA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}
+{"version":3,"file":"types-3uX8odDK.d.ts","names":[],"sources":["../src/benchmarks/types.ts"],"mappings":";;KASY;KAQA;UAgBK,qBAAqB;;;EAGpC;;EAEA,SAAS;;EAET,QAAQ;;EAER,SAAS;;EAET,WAAW;;EAEX;;EAEA,SAAS;EACT,WAAW;;UAGI;;;;EAIf;;EAEA;;EAEA,aAAa;;;EAGb,KAAK;EACL;;UAGe;EACf;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;;;;EAKA;;;UAQe,iBAAiB,kBAAkB,oBAAoB;;EAEtE;EACA,SAAS;EACT,WAAW;EACX;EACA,SAAS;EACT;;;;;EAKA,YAAY,OAAO,cAAc,QAAQ,qBAAqB;;EAE9D,SAAS,MAAM,qBAAqB,WAAW,UAAU,YAAY,QAAQ;;;;EAI7E,YAAY,iBAAiB;;UAGd,kBAAkB,4BAA4B;EAC7D;EACA;EACA,QAAQ;EACR,UAAU;EACV,UAAU;EACV,MAAM,qBAAqB;;KAGjB,mBAAmB,oBAAoB,uBAAuB;EACxE,UAAU,kBAAkB;EAC5B,MAAM,qBAAqB;EAC3B,SAAS;MACL,QAAQ,aAAa;;;cAoBd;;;;;;;;;iBAUG,mBACd,gBACA,gBACC"}

package/dist/{types-kBMNdo1X.d.ts → types-Ob1blgI2.d.ts}

@@ -1,5 +1,5 @@
 import { o as CostLedgerHandle, u as CostProvenance } from "./cost-ledger-Czro9wmo.js";
-import { a as RunRecord, d as RunTokenUsage } from "./run-record-D2BFMPGl.js";
+import { a as RunRecord, d as RunTokenUsage } from "./run-record-pBlhZizT.js";
 import { O as ChatClient, g as JudgeInput, t as BootstrapInterval } from "./cluster-Cd0MRbr9.js";
 import { z } from "zod";
 import { SpanKind } from "@tangle-network/agent-trace-contract";
@@ -1012,4 +1012,4 @@ type AnalystRunEvent = {
   result: AnalystRunResult;
 };
 export { ErrorCluster as $, FindingParseOutcome as A, FindingTreatment as B, CalibrationInterval as C, FindingLayer as D, FindingEvidenceUnit as E, independentUnitCount as F, ReadSpanSourceInput as G, TreatmentLayer as H, lineageRoots as I, TRACE_ANALYSIS_LIMITS as J, ReadSpanSourceResult as K, parseAnalystFinding as L, FindingScope as M, FindingScopeReading as N, FindingMeasure as O, ProposalFindingSchema as P, DatasetOverview as Q, readFindingScope as R, makeProposalFinding as S, FindingCalibration as T, createBoundedTraceAnalysisStore as U, TREATMENT_LAYERS as V, BoundedTraceAnalysisStoreOptions as W, TraceAnalysisStoreContext as X, TraceAnalysisStore as Y, DEFAULT_TRACE_ANALYST_BUDGETS as Z, ExecutionProbeRequest as _, AnalystFindingSchemaVersion as a, TraceAnalystFilters as at, computeFindingId as b, AnalystRunEvent as c, TraceAnalystSpanStatus as ct, AnalystRunSummary as d, ViewTraceOversized as dt, QueryTracesPage as et, AnalystSeverity as f, ViewTraceResult as ft, ExecutionProbeOutcome as g, ExecutionProbe as h, AnalystFinding as i, TraceAnalystByteBudgets as it, FindingReaderLabel as j, FindingMethod as k, AnalystRunInputs as l, TraceAnalystTraceSummary as lt, EvidenceRef as m, AnalystContext as n, SearchTraceResult as nt, AnalystInputKind as o, TraceAnalystSpan as ot, AnalystUsageReceipt as p, SpanSourceReader as q, AnalystCost as r, SpanMatchRecord as rt, AnalystRequirements as s, TraceAnalystSpanKind as st, Analyst as t, SearchSpanResult as tt, AnalystRunResult as u, ViewSpansResult as ut, ProposalFinding as v, FINDING_LAYERS as w, makeFinding as x, ProposalFindingOrigin as y, FindingConditions as z };
-//# sourceMappingURL=types-kBMNdo1X.d.ts.map
+//# sourceMappingURL=types-Ob1blgI2.d.ts.map

package/dist/{types-kBMNdo1X.d.ts.map → types-Ob1blgI2.d.ts.map}

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

package/dist/{types-ip2D3-Ib.d.ts → types-efIQ03Uo.d.ts}

@@ -1,13 +1,13 @@
 import { g as PaidCallResult, i as CostChannel, l as CostLedgerSummary, o as CostLedgerHandle, r as CostBreakdown, u as CostProvenance, y as RunPaidCallInput } from "./cost-ledger-Czro9wmo.js";
-import { a as RunRecord, d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-D2BFMPGl.js";
-import { v as ProposalFinding } from "./types-kBMNdo1X.js";
+import { a as RunRecord, d as RunTokenUsage, s as RunSearchCoordinates } from "./run-record-pBlhZizT.js";
+import { v as ProposalFinding } from "./types-Ob1blgI2.js";
 import { R as LlmCallMetadata } from "./cluster-Cd0MRbr9.js";
 import { ht as SeriesDistribution } from "./index-DNXFzSpc.js";
 import { A as SearchLedgerHash, F as SearchNodeRegisteredEvent, G as SearchSplit, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, U as SearchReservation, Z as SearchTask, b as SearchClosedEvent, d as SearchCellCancelledEvent, i as SearchArtifactRef, l as SearchCandidateSurface, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, w as SearchEdgeRecordedEvent, z as SearchOperationRecordedEvent } from "./search-ledger-types-qiYRUo_N.js";
 import { y as LedgerProjector } from "./index-lRKqfyg4.js";
 import { s as TraceStore } from "./store-CMs5wGXP.js";
 import { a as MintedRolloutLine, m as RolloutEvidenceAttempt, t as ChatMessage, y as RolloutRole } from "./schema-PDKQ_iNE.js";
-import "./reward-ST4PXNXF.js";
+import "./reward-ap_R9mCH.js";
 /** Deterministic node id: identical content in one search is one node. */
 declare function searchNodeId(searchId: string, artifactDigest: string): string;
 /** Deterministic cell id: one node on one task in one split at one repeat. */
@@ -1078,4 +1078,4 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
   scenarios: Array<CampaignScenarioIdentity & Pick<TScenario, 'id' | 'kind'>>;
 }
 export { MintRolloutResult as $, LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, SearchProposerView as G, SurfaceProposer as H, ProposedCandidate as I, searchProposerView as J, SearchSummaryOptions as K, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, MintRolloutOptions as Q, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, SearchStateView as X, SearchState as Y, searchUnitScores as Z, GateDecision as _, CampaignResult as a, SearchCompletion as at, GenerationRecord as b, CampaignTraceWriter as c, SearchOperation as ct, DispatchContext as d, SearchUnitScore as dt, RolloutScrubber as et, DispatchFn as f, searchCellId as ft, GateContribution as g, GateContext as h, CampaignCostMeter as i, SearchCell as it, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, SearchScoredCell as lt, GateCheckStatus as m, searchTaskSetDigest as mt, CampaignArtifactWriter as n, mintRolloutRows as nt, CampaignScenarioIdentity as o, SearchDecisionRecord as ot, Gate as p, searchNodeId as pt, renderSearchSummary as q, CampaignCellResult as r, unmintableReasons as rt, CampaignTokenUsage as s, SearchNode as st, CampaignAggregates as t, RolloutSearchLineage as tt, ComponentSurface as u, SearchSpend as ut, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
-//# sourceMappingURL=types-ip2D3-Ib.d.ts.map
+//# sourceMappingURL=types-efIQ03Uo.d.ts.map

package/dist/{types-ip2D3-Ib.d.ts.map → types-efIQ03Uo.d.ts.map}

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

package/dist/wire/index.d.ts

@@ -1,7 +1,7 @@
 import { m as CustomTokenPricing, o as CostLedgerHandle } from "../cost-ledger-Czro9wmo.js";
 import { O as ChatClient } from "../cluster-Cd0MRbr9.js";
 import { s as TraceStore } from "../store-CMs5wGXP.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DTj8eVTR.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DrKk79NU.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";
@@ -213,9 +213,9 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
       value: z.ZodUnknown;
       reason: z.ZodOptional<z.ZodString>;
       severity: z.ZodOptional<z.ZodEnum<{
-        error: "error";
         critical: "critical";
         info: "info";
+        error: "error";
         warning: "warning";
       }>>;
       createdAt: z.ZodString;
@@ -249,9 +249,9 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
     value: z.ZodUnknown;
     reason: z.ZodOptional<z.ZodString>;
     severity: z.ZodOptional<z.ZodEnum<{
-      error: "error";
       critical: "critical";
       info: "info";
+      error: "error";
       warning: "warning";
     }>>;
     createdAt: z.ZodString;

package/docs/adopt-stack.md

@@ -0,0 +1,9 @@
+# Scoped adoption
+
+`scripts/adopt-stack.mjs` exports `plan(root, requested, { consumer })` for a producer adopting packages in one workspace member. `consumer` is a directory relative to the real workspace root, such as `apps/cli`; it must identify an enumerated member and cannot escape the root. Omitting it retains workspace-wide planning.
+
+The selected member's actual importer supplies locked versions and peer context. Unknown selected versions or an unreadable owning lock refuse. Planning still reads the real root manifest, catalog, install constraints and release cohort, and retains publication evidence and holds. Shared policy or cohort edits remain visible in `result.edits`; a producer must review them before applying a plan. Root `$` override references must admit the selected target after planned root/catalog edits; conflicting or unverifiable references refuse for explicit reconciliation.
+
+Pass the result to the existing `writePlan(root, result)` and `install(root, result)`. Only selected member pins become install targets; root policy edits remain root edits. Verify the installed boundary with `resolvedVersions(root, new Map(result.expected), { consumer })` from `scripts/adopt-stack-workspace.mjs`, using the same selector, then run the consumer's maintained acceptance gate. Caller-supplied locks or peer contexts are unsupported.
+
+The CLI accepts `--consumer apps/cli` or `--consumer=apps/cli`; an explicit empty or missing value refuses. The reusable `adopt-stack.yml` workflow exposes the same `consumer` input; its blank default omits the selector. Both paths retain the real root install and apply the same selector to planning and both installed-version checks. Omission keeps workspace-wide behavior.

package/docs/eval-fixtures.md

@@ -56,7 +56,7 @@ Use `validation: 'none'` for prompt-only corpora.
 ```ts
 const scenarios = loadEvalFixtureScenarios('evals', {
   fingerprintConfig: {
-    model: 'claude-sonnet-4-6@2026-06-01',
+    model: 'claude-sonnet-5-5',
     tools: ['shell', 'edit'],
   },
 })
@@ -66,7 +66,7 @@ const plan = planEvalFixtureRun({
   runDir: '.agent-eval/runs/coding',
   dispatchRef: 'codex/sandbox/v1',
   fingerprintConfig: {
-    model: 'claude-sonnet-4-6@2026-06-01',
+    model: 'claude-sonnet-5-5',
     tools: ['shell', 'edit'],
   },
 })

package/docs/search-ledger.md

@@ -200,6 +200,7 @@ metaSearch.bestPolicyConfiguration: unknown — no configuration of vb/coder ·
 ```
 
 Every signal reports honestly rather than guessing: at 2 nodes and 1 shared unit, this real climb is below every lens's `insufficient`/`none` threshold, so `operatorYield`, `front`, `taskMatrix`, `editCredit`, `landscape` and `skillManifold` all say so instead of printing a number.
+The objective key is `subject · metric (direction) · judge revision`. The transcript above was recorded before the revision was part of the key.
 The two `--wired` behaviors above (`incumbentWithOperatorBandit`, `draftOnPlateau`, `nextUnitExtension`) fall back to their base policy's own behavior on exactly this "insufficient" case — the same code path a synthetic ledger with real signal values exercises, proved in each lens's own PR.
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {
@@ -244,10 +244,10 @@
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^9.1.0",
     "@hono/node-server": "^2.1.5",
-    "@tangle-network/agent-core": "^1.0.0",
-    "@tangle-network/agent-interface": "^5.10.2",
-    "@tangle-network/agent-trace-contract": "^2.2.0",
-    "@tangle-network/harness-sessions": "^1.0.8",
+    "@tangle-network/agent-core": "^1.0.3",
+    "@tangle-network/agent-interface": "^5.10.20",
+    "@tangle-network/agent-trace-contract": "^2.2.2",
+    "@tangle-network/harness-sessions": "^1.0.11",
     "hono": "^4.13.14",
     "linear-sum-assignment": "1.0.9",
     "re2js": "2.9.0",

package/dist/agent-profile-Dngk3LZ0.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-profile-Dngk3LZ0.js","names":[],"sources":["../src/agent-profile.ts"],"sourcesContent":["import { createHash } from 'node:crypto'\nimport type { AgentProfile } from '@tangle-network/agent-interface'\nimport { type HarnessType, harnessSupportsModel } from '@tangle-network/agent-interface'\nimport { ValidationError } from './errors'\nimport { canonicalString } from './ledger-core/canonical'\n\nexport type { AgentProfile, HarnessType } from '@tangle-network/agent-interface'\n\n/**\n * The agentic coding harnesses an eval sweeps by default — the ones we care about\n * ranking. This is the SINGLE source of that list; consumers import it instead of\n * re-declaring their own (a re-declared list is how the fleet drifts). Pass an\n * explicit `harnesses` (e.g. `harnessTypeSchema.options` for literally every known\n * harness) to widen beyond these.\n */\nexport const CODING_HARNESSES: readonly HarnessType[] = [\n  'opencode',\n  'claude-code',\n  'codex',\n  'kimi-code',\n]\n\nexport interface ProfileAxisSpec {\n  /** The domain profile to sweep. Its prompt/tools/skills are held fixed; only the\n   *  harness and model vary. `model.default` is the fallback model. */\n  base: AgentProfile\n  /** Harnesses to cross. Default: {@link CODING_HARNESSES}. */\n  harnesses?: readonly HarnessType[]\n  /** Models to cross. Default: `[base.model.default]` — one model, i.e. today's\n   *  single-model behaviour, so omitting this never changes an existing run. */\n  models?: readonly string[]\n  /** Force every (harness, model) pair verbatim, even ones the harness can't run —\n   *  for deliberately testing failure modes. Default (false): SNAP instead — a\n   *  vendor-locked harness runs only the swept models in its family, or its native\n   *  default when it supports none, so no harness is dropped and none gets a\n   *  guaranteed-failing foreign-model cell. */\n  keepIncompatible?: boolean\n}\n\n/** Model sentinel for a vendor-locked harness that supports none of the swept models:\n *  it carries no provider prefix, so `harnessSupportsModel` accepts it and the harness\n *  resolves it to its own native default model at runtime (e.g. kimi-code → its Kimi\n *  model). Lets `expandProfileAxes` snap-instead-of-drop without a per-harness flagship\n *  table that would rot as router catalogs change. */\nexport const HARNESS_NATIVE_MODEL = 'default'\n\n/**\n * Expand a base profile across the harness × model matrix into the `AgentProfile[]`\n * that `runProfileMatrix` / `selfImprove` score — the ONE place \"which harnesses ×\n * which models do we evaluate\" lives, so no product hand-rolls its own harness list\n * or column→profile mapping (the pattern that let those copies drift and silently\n * break the harness pivot).\n *\n * Each cell clones `base`, sets the canonical top-level `harness` and `model.default`,\n * and stamps `metadata.harness` + `metadata.harnessModel` for matrix grouping. Both\n * metadata fields are hash-bearing, so every cell gets a distinct `agentProfileId` row\n * and results join back by harness/model via {@link harnessAxisOf} with no\n * hand-recomputed key. A vendor-locked harness snaps to its family's swept models — or\n * its native default ({@link HARNESS_NATIVE_MODEL}) when it supports none — so every\n * requested harness runs; `keepIncompatible` forces every pair verbatim.\n *\n * Omit `harnesses`/`models` to sweep the full default set — the \"turn it on for\n * everything we care about\" switch, identical in shape whether one harness or all.\n */\nexport function expandProfileAxes(spec: ProfileAxisSpec): AgentProfile[] {\n  const harnesses = spec.harnesses ?? CODING_HARNESSES\n  if (harnesses.length === 0) throw new ValidationError('expandProfileAxes: no harnesses to sweep')\n  const baseModel = spec.base.model?.default\n  const models = spec.models ?? (baseModel ? [baseModel] : [])\n  if (models.length === 0) {\n    throw new ValidationError(\n      'expandProfileAxes: no models to sweep — base profile has no model.default and none were supplied',\n    )\n  }\n  const out: AgentProfile[] = []\n  const seen = new Set<string>()\n  for (const harness of harnesses) {\n    // A universal (router-backed) harness — opencode/pi/claudish, and claude-code/codex\n    // since agent-interface 5.6.0 — runs every swept model. A vendor-locked harness\n    // (kimi-code) runs only the swept models in its own family; when it supports NONE\n    // of them it snaps to its native default (the `HARNESS_NATIVE_MODEL` sentinel it\n    // resolves at runtime) rather than being dropped, so every requested harness still appears in the\n    // sweep on a model it can actually run — e.g. sweeping `deepseek/x` puts opencode\n    // on deepseek and kimi-code on its own Kimi model, a real head-to-head.\n    // `keepIncompatible` forces every (harness, model) pair verbatim (failure-mode runs).\n    const supported = spec.keepIncompatible\n      ? models\n      : models.filter((model) => harnessSupportsModel(harness, model))\n    const effective = supported.length > 0 ? supported : [HARNESS_NATIVE_MODEL]\n    for (const model of effective) {\n      const profile: AgentProfile = {\n        ...spec.base,\n        harness,\n        name: `${spec.base.name ?? 'agent'}/${harness}/${model}`,\n        model: { ...spec.base.model, default: model },\n        metadata: { ...(spec.base.metadata ?? {}), harness, harnessModel: model },\n      }\n      const id = agentProfileId(profile)\n      if (seen.has(id)) continue\n      seen.add(id)\n      out.push(profile)\n    }\n  }\n  if (out.length === 0) {\n    // Unreachable in normal use — snapping guarantees ≥1 cell per harness — but keep a\n    // fail-closed guard so a future refactor can't silently produce an empty sweep.\n    throw new ValidationError(\n      `expandProfileAxes: produced no profiles (harnesses=[${harnesses.join(', ')}], models=[${models.join(', ')}]).`,\n    )\n  }\n  return out\n}\n\n/**\n * Read the (harness, model) a matrix cell ran under, off a profile or a result row's\n * profile — the join-back for a `byHarness` pivot. Returns undefined when the profile\n * wasn't produced by {@link expandProfileAxes}. Callers group `result.byProfile` by\n * this instead of recomputing an id (recomputing the wrong key is what broke the pivot\n * in the hand-rolled copies).\n */\nexport function harnessAxisOf(\n  profile: Pick<AgentProfile, 'metadata'>,\n): { harness: HarnessType; model: string } | undefined {\n  const m = profile.metadata as Record<string, unknown> | undefined\n  const harness = m?.harness\n  const model = m?.harnessModel\n  if (typeof harness === 'string' && typeof model === 'string') {\n    return { harness: harness as HarnessType, model }\n  }\n  return undefined\n}\n\n/**\n * Collision-resistant, path-safe, human-readable profile id for eval artifacts.\n * Scorecard joins still use `agentProfileHash`; this id is for run ids, matrix\n * keys, and directory names where two profiles must not collapse onto one row.\n * The suffix is the first 64 bits of the behaviour hash, enough for ordinary\n * eval matrices while keeping filenames readable.\n */\nexport function agentProfileId(profile: AgentProfile): string {\n  const label = pathSafeProfileLabel(agentProfileDisplayLabel(profile)) ?? 'profile'\n  return `${label}-${agentProfileHash(profile).slice(0, 16)}`\n}\n\n/**\n * Model snapshot used for `RunRecord.model`. Eval surfaces require a concrete\n * model id because run records reject bare/missing model aliases.\n */\nexport function agentProfileModelId(profile: AgentProfile): string {\n  const model = profile.model?.default?.trim()\n  if (!model) {\n    const label = agentProfileDisplayLabel(profile) ?? 'unnamed profile'\n    throw new ValidationError(\n      `AgentProfile \"${label}\" has no model.default — cannot record eval run`,\n    )\n  }\n  return model\n}\n\nfunction agentProfileDisplayLabel(profile: AgentProfile): string | undefined {\n  return profile.name?.trim() || profile.version?.trim() || undefined\n}\n\nfunction pathSafeProfileLabel(label: string | undefined): string | undefined {\n  const safe = label\n    ?.trim()\n    .replace(/[^A-Za-z0-9._-]+/g, '-')\n    .replace(/-+/g, '-')\n    .replace(/^-|-$/g, '')\n  return safe || undefined\n}\n\nfunction compact<T extends Record<string, unknown>>(input: T): Partial<T> {\n  const out: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(input)) {\n    if (value !== undefined) out[key] = value\n  }\n  return out as Partial<T>\n}\n\n/**\n * Deterministic behaviour identity for the canonical\n * `@tangle-network/agent-interface` AgentProfile.\n *\n * `name` and `description` are labels and do not affect the hash. Profile\n * `version`, prompt, model hints, tools, resources, hooks, modes, permissions,\n * and extensions do affect the hash. Resource array order is hash-bearing\n * because mount order can change agent behaviour. Undefined fields are treated\n * as absent; explicit `null` fields remain hash-bearing.\n */\nexport function agentProfileHash(profile: AgentProfile): string {\n  const model = agentProfileModelId(profile)\n  const behaviour = compact({\n    ...profile,\n    name: undefined,\n    description: undefined,\n    tags: profile.tags ? [...profile.tags].sort() : undefined,\n    model: compact({ ...profile.model, default: model }),\n  })\n  return createHash('sha256').update(canonicalString(behaviour)).digest('hex')\n}\n"],"mappings":"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"}

package/dist/eval-campaign-Dq8DEKmy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"eval-campaign-Dq8DEKmy.js","names":[],"sources":["../src/eval-campaign.ts"],"sourcesContent":["/**\n * EvalCampaign — opinionated matrix runner that wires the four\n * capture-integrity directives by construction.\n *\n * The canonical benchmark shape — matrix runner → for each\n * (variant, scenario, seed) → start a TraceEmitter → call LLMs → end the\n * run → analyze — has a bug class at the integration boundary: raw\n * events not captured, route silently wrong, integrity not asserted,\n * analyst never run. The directives in `SKILL.md § Capture integrity`\n * are the mitigations.\n *\n * `EvalCampaign` is the structural fix — consumers don't wire the\n * integrity surface themselves; the campaign owns it. Specifically:\n *\n *   - constructs a per-run `TraceStore` and `RawProviderSink` via factories\n *   - builds the run's `ChatClient` through `chatFactory`, handing it the\n *     run's raw sink and trace context — a transport built any other way has\n *     no raw HTTP envelope, and `assertRunCaptured` says so\n *   - calls `assertRunCaptured` after every `endRun` and routes failures\n *     through a configurable policy (`throw` / `mark_failed` / `log`)\n *   - assembles per-run `RunRecord`s and runs `researchReport` at the end\n *     so the campaign artifact is launch-decision-grade by default\n *   - embeds the campaign fingerprint (a SHA-256 over the canonicalised\n *     run set) and optional `preregistrationHash` in the report\n *\n * The runner contract is intentionally narrow: produce a `CampaignRunOutcome`\n * given a fully-wired `CampaignRunContext`. Everything orchestration-shaped\n * lives in the campaign. This is the inversion-of-control point — consumers\n * stop writing matrix runners and start writing scenario-runners.\n *\n * Out of scope for v1 (tracked in `docs/research-report-methodology.md`):\n *\n *   - Distributed/cluster execution (concurrency is local async)\n *   - Adaptive sampling / sequential interim looks\n *   - Resume from partial state across crashes\n *   - LLM-call retry beyond what the caller's transport already does\n */\n\nimport {\n  type AgentProfileCell,\n  type AgentProfileCellInput,\n  buildAgentProfileCell,\n  verifyAgentProfileCell,\n} from './agent-profile-cell'\nimport type { ChatClient } from './analyst/chat-client'\nimport { hashJson } from './pre-registration'\nimport type {\n  JudgeScoresRecord,\n  RunCostProvenance,\n  RunJudgeMetadata,\n  RunOutcome,\n  RunRecord,\n  RunSplitTag,\n  RunTaskFailure,\n  RunTokenUsage,\n} from './run-record'\nimport { validateRunRecord } from './run-record'\nimport { type ResearchReport, type ResearchReportOptions, researchReport } from './summary-report'\nimport type { RunCompleteHook } from './trace/emitter'\nimport { TraceEmitter } from './trace/emitter'\nimport {\n  assertRunCaptured,\n  RunIntegrityError,\n  type RunIntegrityExpectations,\n  type RunIntegrityReport,\n} from './trace/integrity'\nimport { FileSystemRawProviderSink, type RawProviderSink } from './trace/raw-provider-sink'\nimport type { TraceStore } from './trace/store'\n\n// ── Public types ─────────────────────────────────────────────────────────\n\nexport interface CampaignVariant<V> {\n  id: string\n  payload: V\n}\n\nexport interface CampaignScenario {\n  scenarioId: string\n  /** Free-form metadata propagated to runs and reports. */\n  tags?: Record<string, string>\n}\n\nexport interface CampaignRunContext<V> {\n  /** Stable run id. The campaign generates this; the runner does not. */\n  runId: string\n  /** Logical experiment id (campaignId by default; overridable per-run via opts). */\n  experimentId: string\n  variant: V\n  variantId: string\n  scenarioId: string\n  scenarioTags: Record<string, string>\n  seed: number\n  splitTag: RunSplitTag\n  /**\n   * The TraceEmitter for this run, with `onRunComplete` hooks pre-wired\n   * (analyst auto-execution if configured, plus integrity check). The\n   * runner MUST call `emitter.startRun` before doing any work and either\n   * `emitter.endRun` or `emitter.abortRun` before returning.\n   */\n  emitter: TraceEmitter\n  store: TraceStore\n  rawSink: RawProviderSink\n  /**\n   * The run's model transport, built by `chatFactory` with this run's\n   * `rawSink` and `runId` already bound.\n   */\n  chat: ChatClient\n}\n\n/** What the campaign binds into the run's transport. */\nexport interface CampaignChatWiring {\n  /**\n   * Raw provider sink for this run. Bind it into the transport: the campaign's\n   * integrity check requires every LLM span to carry a matching raw request\n   * event, so a transport built without it fails `assertRunCaptured`.\n   */\n  rawSink: RawProviderSink\n  runId: string\n}\n\ninterface CampaignRunOutcomeFields {\n  /** Did the run pass? Mirrors `RunOutcome.pass` semantics. */\n  pass: boolean\n  /** Score for the run on its split. Maps to `searchScore` or `holdoutScore`. */\n  score: number\n  /** Cost in USD, or null when the runner could not capture it. */\n  costUsd: number | null\n  /** Source of the cost amount. */\n  costProvenance: RunCostProvenance\n  tokenUsage: RunTokenUsage\n  /** Snapshot model id (e.g. `claude-sonnet-4-6@2025-04-15`). */\n  model: string\n  /** sha256 of the effective prompt sent to the model. */\n  promptHash: string\n  /** sha256 of the effective config (model, temperature, tools, judges, splits). */\n  configHash: string\n  /** Optional extra numeric metrics to land in `outcome.raw`. */\n  raw?: Record<string, number>\n  /** Optional judge metadata when a judge was used. */\n  judgeMetadata?: RunJudgeMetadata\n  /**\n   * Optional per-judge / per-dim breakdown for ensemble-judged runs.\n   * Propagated to `outcome.judgeScores` on the resulting `RunRecord`.\n   * Single-judge or scalar-only runs leave this unset.\n   */\n  judgeScores?: JudgeScoresRecord\n  /**\n   * Agent profile cell observed by the runner. When supplied, it overrides\n   * `EvalCampaignOptions.agentProfile` for this run and must match the\n   * outcome's `model` and `promptHash`.\n   */\n  agentProfile?: AgentProfileCell | AgentProfileCellInput\n}\n\n/** Campaign result with the same task-failure invariant as `RunRecord`. */\nexport type CampaignRunOutcome = CampaignRunOutcomeFields & RunTaskFailure\n\nexport type CampaignRunner<V> = (ctx: CampaignRunContext<V>) => Promise<CampaignRunOutcome>\n\nexport type CampaignIntegrityPolicy = 'throw' | 'mark_failed' | 'log'\n\nexport interface EvalCampaignOptions<V> {\n  /**\n   * Stable id for the campaign. Used as the default `experimentId` on\n   * every run, and folded into the campaign fingerprint.\n   */\n  campaignId: string\n  variants: CampaignVariant<V>[]\n  scenarios: CampaignScenario[]\n  /** Default `[0, 1, 2]`. */\n  seeds?: number[]\n  /** Default `'holdout'` — the split that anchors a launch decision. */\n  splitTag?: RunSplitTag\n  /** Git SHA the campaign is run against. Mandatory; `RunRecord` rejects unset. */\n  commitSha: string\n  /**\n   * Build the model transport for one run. agent-eval executes no paid model:\n   * the caller owns the transport and the credential never enters this\n   * package. The campaign calls this once per run and passes the run's raw\n   * provider sink and `runId`, so a transport that binds them captures the\n   * raw HTTP envelope `assertRunCaptured` checks for.\n   */\n  chatFactory: (wiring: CampaignChatWiring) => ChatClient\n  /**\n   * Caller-declared identity of the execution route, folded into the campaign\n   * fingerprint so two campaigns run against different endpoints do not share\n   * one identity. agent-eval no longer knows the endpoint; the owner of\n   * execution names it.\n   */\n  executionRef?: string\n  /**\n   * Per-run TraceStore factory. Common shape: a fresh store per run keyed\n   * on `runId`. Implementations that share a store across the campaign\n   * are valid — the campaign only writes through `emitter`.\n   */\n  storeFactory: (params: CampaignFactoryParams) => TraceStore\n  /**\n   * Per-run RawProviderSink factory. Defaults to `FileSystemRawProviderSink`\n   * rooted at `${workDir}/raw-events/${runId}` if `workDir` is supplied;\n   * otherwise required. Forensic capture is non-negotiable in a campaign\n   * run — pass `NoopRawProviderSink` explicitly if you want to opt out.\n   */\n  rawSinkFactory?: (params: CampaignFactoryParams) => RawProviderSink\n  /**\n   * Filesystem root for default `rawSinkFactory`. Ignored if\n   * `rawSinkFactory` is supplied.\n   */\n  workDir?: string\n  /**\n   * Extra `onRunComplete` hooks the campaign appends (after its own\n   * integrity-check hook). Pass `traceAnalystOnRunComplete(...)` here.\n   */\n  onRunComplete?: RunCompleteHook[]\n  /**\n   * Per-run integrity expectations. Defaults to:\n   *   `{ llmSpansMin: 1, requireRawCoverageOfLlmSpans: true, requireOutcome: true }`.\n   * Override (e.g. `{ llmSpansMin: 0 }`) for runs that don't call LLMs.\n   */\n  integrity?: RunIntegrityExpectations\n  /** Behaviour when integrity fails. Default `'mark_failed'`. */\n  onIntegrityFailure?: CampaignIntegrityPolicy\n  /**\n   * Per-run runner. Receives a fully-wired context; produces an outcome\n   * the campaign converts into a `RunRecord`.\n   */\n  runner: CampaignRunner<V>\n  /**\n   * If set, the campaign computes `researchReport` at the end. `comparator`\n   * is a `variantId`. Other fields are forwarded verbatim.\n   */\n  report?: { comparator?: string } & Omit<\n    ResearchReportOptions,\n    'comparator' | 'preregistrationHash' | 'generatedAt'\n  >\n  /**\n   * Hash of a signed `HypothesisManifest` (see `pre-registration.ts`).\n   * Embedded in the campaign fingerprint and the research report.\n   */\n  preregistrationHash?: string\n  /** Local concurrency. Default `1` (sequential). */\n  concurrency?: number\n  /**\n   * Override the time source. Tests pass a mock to make wallMs deterministic.\n   */\n  now?: () => number\n  /** Override the runId generator. Tests pin this. */\n  runId?: (params: CampaignFactoryParams) => string\n  /**\n   * Agent profile cell for campaign runs. Static profiles can pass an object;\n   * routers or variant-specific harnesses can pass a factory. The campaign\n   * stamps the built cell onto every `RunRecord` and rejects profile/model or\n   * profile/prompt contradictions.\n   */\n  agentProfile?:\n    | AgentProfileCell\n    | AgentProfileCellInput\n    | ((\n        params: CampaignFactoryParams & {\n          variant: V\n          scenarioTags: Record<string, string>\n        },\n      ) =>\n        | AgentProfileCell\n        | AgentProfileCellInput\n        | Promise<AgentProfileCell | AgentProfileCellInput>)\n}\n\nexport interface CampaignFactoryParams {\n  campaignId: string\n  runId: string\n  variantId: string\n  scenarioId: string\n  seed: number\n}\n\nexport interface FailedRun {\n  runId: string\n  variantId: string\n  scenarioId: string\n  seed: number\n  reason: string\n  error?: string\n}\n\nexport interface EvalCampaignResult {\n  campaignId: string\n  /** SHA-256 over canonicalised `(variantIds, scenarioIds, seeds, comparator, splitTag, executionRef, preregistrationHash)`. */\n  campaignFingerprint: string\n  preregistrationHash: string | null\n  /** Successful runs only. Failed runs land in `failedRuns`. */\n  runs: RunRecord[]\n  /** Integrity reports for every successful run. */\n  integrityReports: RunIntegrityReport[]\n  failedRuns: FailedRun[]\n  /** Computed when `report` is set on options. */\n  report?: ResearchReport\n  startedAt: string\n  endedAt: string\n}\n\n// ── Implementation ───────────────────────────────────────────────────────\n\nconst DEFAULT_INTEGRITY: RunIntegrityExpectations = {\n  llmSpansMin: 1,\n  requireRawCoverageOfLlmSpans: true,\n  requireOutcome: true,\n}\n\ntype CampaignCell<V> = { variant: CampaignVariant<V>; scenario: CampaignScenario; seed: number }\n\ntype CampaignRunResult = { record: RunRecord; integrity: RunIntegrityReport }\n\n/** Resolved options shared by every step of one campaign. */\ninterface CampaignSettings {\n  seeds: number[]\n  splitTag: RunSplitTag\n  concurrency: number\n  integrity: RunIntegrityExpectations\n  onIntegrityFailure: CampaignIntegrityPolicy\n  now: () => number\n  executionRef: string | null\n  preregistrationHash: string | null\n  rawSinkFactory: (params: CampaignFactoryParams) => RawProviderSink\n}\n\n/**\n * Mutable state of one campaign's worker pool.\n *\n * A genuine (non-CellExecutionError) error from any worker is a bug, not a\n * run-level failure. We must NOT let `Promise.all` reject mid-flight and\n * orphan the other workers' in-progress runs (emitters never finalized,\n * sinks/handles leak, partial work silently discarded). Instead: capture the\n * first genuine error, stop dispatching new cells so in-flight workers wind\n * down, finalize every still-open run, then re-throw the aggregated error.\n */\ninterface CampaignPool<V> {\n  opts: EvalCampaignOptions<V>\n  settings: CampaignSettings\n  cells: CampaignCell<V>[]\n  cursor: number\n  aborting: boolean\n  genuineErrors: unknown[]\n  /**\n   * Emitters for runs that are currently mid-flight, keyed by runId. A worker\n   * registers its emitter before invoking the runner and removes it once the\n   * run is finalized (via endRun/abortRun, success or failure). Anything left\n   * here after the pool settles is an orphan we must abort.\n   */\n  openRuns: Map<string, TraceEmitter>\n  runs: RunRecord[]\n  integrityReports: RunIntegrityReport[]\n  failedRuns: FailedRun[]\n}\n\nexport async function runEvalCampaign<V>(\n  opts: EvalCampaignOptions<V>,\n): Promise<EvalCampaignResult> {\n  assertCampaignPreflight(opts)\n  const settings = resolveCampaignSettings(opts)\n  const campaignFingerprint = await fingerprintCampaign(opts, settings)\n\n  const startedAt = new Date(settings.now()).toISOString()\n  const pool: CampaignPool<V> = {\n    opts,\n    settings,\n    cells: planCampaignCells(opts, settings.seeds),\n    cursor: 0,\n    aborting: false,\n    genuineErrors: [],\n    openRuns: new Map(),\n    runs: [],\n    integrityReports: [],\n    failedRuns: [],\n  }\n  await drainCampaignPool(pool)\n\n  const report = await buildCampaignReport(opts, settings, pool.runs)\n  const endedAt = new Date(settings.now()).toISOString()\n\n  return {\n    campaignId: opts.campaignId,\n    campaignFingerprint,\n    preregistrationHash: settings.preregistrationHash,\n    runs: pool.runs,\n    integrityReports: pool.integrityReports,\n    failedRuns: pool.failedRuns,\n    report,\n    startedAt,\n    endedAt,\n  }\n}\n\n/** Reject structurally invalid campaigns before any work starts. */\nfunction assertCampaignPreflight<V>(opts: EvalCampaignOptions<V>): void {\n  if (opts.variants.length === 0) {\n    throw new Error('runEvalCampaign: variants must be non-empty.')\n  }\n  if (opts.scenarios.length === 0) {\n    throw new Error('runEvalCampaign: scenarios must be non-empty.')\n  }\n  const variantIds = new Set<string>()\n  for (const v of opts.variants) {\n    if (variantIds.has(v.id)) {\n      throw new Error(`runEvalCampaign: duplicate variant id \"${v.id}\".`)\n    }\n    variantIds.add(v.id)\n  }\n  const scenarioIds = new Set<string>()\n  for (const s of opts.scenarios) {\n    if (scenarioIds.has(s.scenarioId)) {\n      throw new Error(`runEvalCampaign: duplicate scenarioId \"${s.scenarioId}\".`)\n    }\n    scenarioIds.add(s.scenarioId)\n  }\n  if (opts.report?.comparator && !variantIds.has(opts.report.comparator)) {\n    throw new Error(\n      `runEvalCampaign: report.comparator \"${opts.report.comparator}\" is not a configured variantId.`,\n    )\n  }\n  if (!opts.commitSha) {\n    throw new Error('runEvalCampaign: commitSha is required (every RunRecord needs it).')\n  }\n}\n\n/** Apply defaults to the optional campaign options. */\nfunction resolveCampaignSettings<V>(opts: EvalCampaignOptions<V>): CampaignSettings {\n  return {\n    seeds: opts.seeds ?? [0, 1, 2],\n    splitTag: opts.splitTag ?? 'holdout',\n    concurrency: Math.max(1, opts.concurrency ?? 1),\n    integrity: { ...DEFAULT_INTEGRITY, ...(opts.integrity ?? {}) },\n    onIntegrityFailure: opts.onIntegrityFailure ?? 'mark_failed',\n    now: opts.now ?? (() => Date.now()),\n    executionRef: opts.executionRef ?? null,\n    preregistrationHash: opts.preregistrationHash ?? null,\n    rawSinkFactory: opts.rawSinkFactory ?? defaultRawSinkFactory(opts.workDir),\n  }\n}\n\n/** SHA-256 over the canonicalised matrix definition. */\nfunction fingerprintCampaign<V>(\n  opts: EvalCampaignOptions<V>,\n  settings: CampaignSettings,\n): Promise<string> {\n  return hashJson({\n    campaignId: opts.campaignId,\n    variants: opts.variants.map((v) => v.id).sort(),\n    scenarios: opts.scenarios.map((s) => s.scenarioId).sort(),\n    seeds: [...settings.seeds].sort((a, b) => a - b),\n    splitTag: settings.splitTag,\n    comparator: opts.report?.comparator ?? null,\n    executionRef: settings.executionRef,\n    preregistrationHash: settings.preregistrationHash,\n  })\n}\n\n/** Expand variants x scenarios x seeds, variant-major. */\nfunction planCampaignCells<V>(opts: EvalCampaignOptions<V>, seeds: number[]): CampaignCell<V>[] {\n  const cells: CampaignCell<V>[] = []\n  for (const variant of opts.variants) {\n    for (const scenario of opts.scenarios) {\n      for (const seed of seeds) {\n        cells.push({ variant, scenario, seed })\n      }\n    }\n  }\n  return cells\n}\n\n/**\n * Run the bounded-concurrency worker pool to completion, finalize any run left\n * open, and re-throw the genuine errors the workers captured.\n */\nasync function drainCampaignPool<V>(pool: CampaignPool<V>): Promise<void> {\n  const workers = Array.from(\n    { length: Math.min(pool.settings.concurrency, pool.cells.length) },\n    () => campaignWorker(pool),\n  )\n  // allSettled (not all): a genuine error in one worker must not reject the\n  // pool mid-flight and orphan the others. Each worker captures its own\n  // genuine error into `genuineErrors` and returns; we re-throw below.\n  await Promise.allSettled(workers)\n\n  // Finalize any run still open after the pool wound down. With the\n  // stop-dispatch flag these are the runs that were mid-flight in peer workers\n  // when the first genuine error fired — abort them so their emitters finalize\n  // (hooks fire, store records a terminal status) instead of leaking.\n  for (const [runId, emitter] of pool.openRuns) {\n    await finalizeAbort(emitter, runId, 'campaign aborted: genuine error in a sibling run')\n  }\n  pool.openRuns.clear()\n\n  if (pool.genuineErrors.length > 0) {\n    throw pool.genuineErrors.length === 1\n      ? pool.genuineErrors[0]\n      : new AggregateError(\n          pool.genuineErrors,\n          `runEvalCampaign: ${pool.genuineErrors.length} runs failed with genuine (non-run-level) errors`,\n        )\n  }\n}\n\n/** Pull cells off the shared cursor until none remain or the pool is aborting. */\nasync function campaignWorker<V>(pool: CampaignPool<V>): Promise<void> {\n  while (!pool.aborting) {\n    const i = pool.cursor++\n    if (i >= pool.cells.length) return\n    const cell = pool.cells[i]!\n    try {\n      const result = await runCampaignCell(pool, cell)\n      pool.runs.push(result.record)\n      pool.integrityReports.push(result.integrity)\n    } catch (err) {\n      if (err instanceof CellExecutionError) {\n        pool.failedRuns.push(err.failed)\n        if (err.integrity) pool.integrityReports.push(err.integrity)\n      } else {\n        // Genuine bug — not a runner failure, not an integrity failure.\n        // Capture it and stop dispatching so peers wind down gracefully;\n        // re-thrown after the pool settles. Do not surface here — that would\n        // reject Promise.all and orphan the other workers' runs.\n        pool.genuineErrors.push(err)\n        pool.aborting = true\n        return\n      }\n    }\n  }\n}\n\n/** Run one matrix cell: runner, integrity check, then the validated RunRecord. */\nasync function runCampaignCell<V>(\n  pool: CampaignPool<V>,\n  cell: CampaignCell<V>,\n): Promise<CampaignRunResult> {\n  const { opts, settings } = pool\n  const runId = (opts.runId ?? defaultRunId)({\n    campaignId: opts.campaignId,\n    runId: '', // unused by default generator\n    variantId: cell.variant.id,\n    scenarioId: cell.scenario.scenarioId,\n    seed: cell.seed,\n  })\n  const factoryParams: CampaignFactoryParams = {\n    campaignId: opts.campaignId,\n    runId,\n    variantId: cell.variant.id,\n    scenarioId: cell.scenario.scenarioId,\n    seed: cell.seed,\n  }\n  const store = opts.storeFactory(factoryParams)\n  const rawSink = settings.rawSinkFactory(factoryParams)\n\n  const emitter = new TraceEmitter(store, {\n    runId,\n    now: opts.now,\n    onRunComplete: opts.onRunComplete,\n  })\n  // Track this run as open so a genuine error elsewhere in the pool can\n  // finalize it instead of orphaning it. Removed in the finally below.\n  pool.openRuns.set(runId, emitter)\n\n  const chat = opts.chatFactory({ rawSink, runId })\n\n  const ctx: CampaignRunContext<V> = {\n    runId,\n    experimentId: opts.campaignId,\n    variant: cell.variant.payload,\n    variantId: cell.variant.id,\n    scenarioId: cell.scenario.scenarioId,\n    scenarioTags: cell.scenario.tags ?? {},\n    seed: cell.seed,\n    splitTag: settings.splitTag,\n    emitter,\n    store,\n    rawSink,\n    chat,\n  }\n\n  try {\n    const wallStart = settings.now()\n    const outcome = await invokeCampaignRunner(opts, cell, ctx)\n    const wallMs = settings.now() - wallStart\n\n    const integrityReport = await assertRunCaptured(store, runId, {\n      ...settings.integrity,\n      rawSink,\n    })\n    if (!integrityReport.ok) admitOrRejectIntegrity(settings, cell, runId, integrityReport)\n\n    const record = buildCampaignRunRecord(opts, settings, cell, runId, outcome, wallMs)\n    await stampAgentProfile(opts, cell, record, runId, outcome)\n    return { record: validateRunRecord(record), integrity: integrityReport }\n  } finally {\n    // This run's worker has finished with it (success, run-level failure, or\n    // genuine error). It is no longer the pool's job to finalize — drop it so\n    // the post-settle sweep doesn't double-abort a finalized run.\n    pool.openRuns.delete(runId)\n  }\n}\n\n/** Invoke the runner; a throw aborts the run and becomes a run-level failure. */\nasync function invokeCampaignRunner<V>(\n  opts: EvalCampaignOptions<V>,\n  cell: CampaignCell<V>,\n  ctx: CampaignRunContext<V>,\n): Promise<CampaignRunOutcome> {\n  try {\n    return await opts.runner(ctx)\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err)\n    // The runner threw mid-execution. Abort the run so the emitter\n    // finalizes. The only benign abortRun failure is \"the runner never\n    // started the run\" (nothing to finalize). A store-write failure (disk\n    // full, FS error) is a genuine diagnostic — surface it rather than\n    // masking it as a plain runner failure.\n    await finalizeAbort(ctx.emitter, ctx.runId, message)\n    throw new CellExecutionError({\n      runId: ctx.runId,\n      variantId: cell.variant.id,\n      scenarioId: cell.scenario.scenarioId,\n      seed: cell.seed,\n      reason: 'runner_threw',\n      error: message,\n    })\n  }\n}\n\n/** Apply the integrity-failure policy to a report that is not ok. */\nfunction admitOrRejectIntegrity<V>(\n  settings: CampaignSettings,\n  cell: CampaignCell<V>,\n  runId: string,\n  integrityReport: RunIntegrityReport,\n): void {\n  switch (settings.onIntegrityFailure) {\n    case 'throw':\n      throw new RunIntegrityError(integrityReport)\n    case 'mark_failed':\n      throw new CellExecutionError(\n        {\n          runId,\n          variantId: cell.variant.id,\n          scenarioId: cell.scenario.scenarioId,\n          seed: cell.seed,\n          reason: 'integrity_failed',\n          error: integrityReport.issues.map((i) => i.code).join(', '),\n        },\n        integrityReport,\n      )\n    case 'log':\n      // Caller wants the run admitted with a flagged report; fall through.\n      break\n  }\n}\n\n/** Assemble the RunRecord for a successful run, before profile stamping. */\nfunction buildCampaignRunRecord<V>(\n  opts: EvalCampaignOptions<V>,\n  settings: CampaignSettings,\n  cell: CampaignCell<V>,\n  runId: string,\n  outcome: CampaignRunOutcome,\n  wallMs: number,\n): RunRecord {\n  const recordOutcome: RunOutcome = {\n    raw: outcome.raw ?? {},\n  }\n  if (settings.splitTag === 'holdout') recordOutcome.holdoutScore = outcome.score\n  else recordOutcome.searchScore = outcome.score\n  if (outcome.judgeScores !== undefined) recordOutcome.judgeScores = outcome.judgeScores\n\n  return {\n    runId,\n    experimentId: opts.campaignId,\n    candidateId: cell.variant.id,\n    seed: cell.seed,\n    model: outcome.model,\n    promptHash: outcome.promptHash,\n    configHash: outcome.configHash,\n    commitSha: opts.commitSha,\n    wallMs,\n    costUsd: outcome.costUsd,\n    costProvenance: outcome.costProvenance,\n    tokenUsage: outcome.tokenUsage,\n    terminalOutcome: 'succeeded',\n    judgeMetadata: outcome.judgeMetadata,\n    outcome: recordOutcome,\n    ...(outcome.failureClass ? { failureClass: outcome.failureClass } : {}),\n    failureMode: outcome.failureMode,\n    splitTag: settings.splitTag,\n    scenarioId: cell.scenario.scenarioId,\n  }\n}\n\n/** Resolve the run's agent profile (outcome first, then options) and stamp it on the record. */\nasync function stampAgentProfile<V>(\n  opts: EvalCampaignOptions<V>,\n  cell: CampaignCell<V>,\n  record: RunRecord,\n  runId: string,\n  outcome: CampaignRunOutcome,\n): Promise<void> {\n  const profileSource =\n    outcome.agentProfile ??\n    (typeof opts.agentProfile === 'function'\n      ? await opts.agentProfile({\n          campaignId: opts.campaignId,\n          runId,\n          variantId: cell.variant.id,\n          scenarioId: cell.scenario.scenarioId,\n          seed: cell.seed,\n          variant: cell.variant.payload,\n          scenarioTags: cell.scenario.tags ?? {},\n        })\n      : opts.agentProfile)\n  if (profileSource !== undefined) {\n    const agentProfile = await resolveAgentProfileCell(profileSource)\n    assertAgentProfileMatchesRun(agentProfile, outcome.model, outcome.promptHash)\n    record.agentProfile = agentProfile\n  }\n}\n\n/** Build the optional research report over the successful runs. */\nasync function buildCampaignReport<V>(\n  opts: EvalCampaignOptions<V>,\n  settings: CampaignSettings,\n  runs: RunRecord[],\n): Promise<ResearchReport | undefined> {\n  if (!opts.report) return undefined\n  const reportOpts: ResearchReportOptions = {\n    ...opts.report,\n    comparator: opts.report.comparator,\n    split: settings.splitTag === 'dev' ? 'search' : settings.splitTag,\n    generatedAt: new Date(settings.now()).toISOString(),\n    preregistrationHash: settings.preregistrationHash ?? undefined,\n  }\n  return researchReport(runs, reportOpts)\n}\n\n// ── Internal ─────────────────────────────────────────────────────────────\n\nclass CellExecutionError extends Error {\n  readonly failed: FailedRun\n  readonly integrity?: RunIntegrityReport\n  constructor(failed: FailedRun, integrity?: RunIntegrityReport) {\n    super(`cell ${failed.variantId}/${failed.scenarioId}@${failed.seed} failed: ${failed.reason}`)\n    this.failed = failed\n    this.integrity = integrity\n  }\n}\n\n/**\n * Abort a run whose owning work threw or was orphaned by a sibling's genuine\n * error, finalizing the emitter so hooks fire and the store records a terminal\n * status. Safe to call unconditionally: it only aborts runs that are still\n * `running`. Two no-op cases are intentional and benign:\n *\n *   - the run was never started (absent from the store) — nothing to finalize\n *   - the run is already terminal (`completed` / `failed` / `aborted`) —\n *     finalizing again would overwrite the real outcome (e.g. flip a passed run\n *     to `aborted` with `{ pass: false, notes: reason }`), so we leave it alone\n *\n * Any OTHER failure of the store read or the abort write (disk full, FS fault,\n * backend down) is a genuine diagnostic and propagates rather than being\n * swallowed.\n */\nasync function finalizeAbort(emitter: TraceEmitter, runId: string, reason: string): Promise<void> {\n  const existing = await emitter.traceStore.getRun(runId)\n  if (existing === undefined) return // run never started; nothing to abort\n  if (existing.status !== 'running') return // already finalized; never overwrite a real outcome\n  // The emitter never throws on a failed store write; it counts it. A failed\n  // abort write is a genuine diagnostic here, so read the count and surface it.\n  const droppedBefore = emitter.captureStats().dropped\n  await emitter.abortRun(reason)\n  const after = emitter.captureStats()\n  if (after.dropped > droppedBefore) {\n    throw new Error(`finalizeAbort: run ${runId} could not be finalized: ${after.lastError}`)\n  }\n}\n\nfunction defaultRawSinkFactory(workDir: string | undefined) {\n  return (params: CampaignFactoryParams): RawProviderSink => {\n    if (!workDir) {\n      throw new Error(\n        'runEvalCampaign: rawSinkFactory not supplied and workDir not set. Pass either to enable raw provider capture, or pass `new NoopRawProviderSink()` via rawSinkFactory to opt out explicitly.',\n      )\n    }\n    return new FileSystemRawProviderSink({\n      dir: `${workDir}/raw-events/${params.runId}`,\n    })\n  }\n}\n\nasync function resolveAgentProfileCell(\n  input: AgentProfileCell | AgentProfileCellInput,\n): Promise<AgentProfileCell> {\n  if (isAgentProfileCell(input)) {\n    if (!(await verifyAgentProfileCell(input))) {\n      throw new Error(`runEvalCampaign: agentProfile.cellId does not match its content`)\n    }\n    return input\n  }\n  return buildAgentProfileCell(input)\n}\n\nfunction isAgentProfileCell(\n  input: AgentProfileCell | AgentProfileCellInput,\n): input is AgentProfileCell {\n  return 'schemaVersion' in input && 'cellId' in input\n}\n\nfunction assertAgentProfileMatchesRun(\n  profile: AgentProfileCell,\n  model: string,\n  promptHash: string,\n): void {\n  if (profile.model !== undefined && profile.model !== model) {\n    throw new Error(\n      `runEvalCampaign: agentProfile.model \"${profile.model}\" does not match outcome.model \"${model}\"`,\n    )\n  }\n  if (profile.promptHash !== undefined && profile.promptHash !== promptHash) {\n    throw new Error(\n      `runEvalCampaign: agentProfile.promptHash \"${profile.promptHash}\" does not match outcome.promptHash \"${promptHash}\"`,\n    )\n  }\n}\n\nfunction defaultRunId(params: CampaignFactoryParams): string {\n  // Stable across re-runs: fingerprint of (campaignId, variantId, scenarioId, seed).\n  // Caller can override via opts.runId for non-deterministic IDs.\n  const base = `${params.campaignId}::${params.variantId}::${params.scenarioId}::${params.seed}`\n  // TWO 32-bit FNV-1a accumulators with different offsets, concatenated for a\n  // 64-bit-wide id. Not crypto-grade; stability and uniqueness are what this\n  // needs. Frozen: the value names a persisted cell, and the second\n  // accumulator's offset is part of the identity, so no single-accumulator\n  // helper can replace it.\n  let h1 = 0x811c9dc5\n  let h2 = 0x12345678\n  for (let i = 0; i < base.length; i++) {\n    const c = base.charCodeAt(i)\n    h1 = Math.imul(h1 ^ c, 0x01000193) >>> 0\n    h2 = Math.imul(h2 ^ c, 0x9e3779b1) >>> 0\n  }\n  return `run-${h1.toString(16).padStart(8, '0')}${h2.toString(16).padStart(8, '0')}`\n}\n"],"mappings":"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"}

package/dist/index-7tWvC0aW.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-7tWvC0aW.d.ts","names":[],"sources":["../src/cost-ledger/errors.ts","../src/cost-ledger/pricing.ts","../src/llm-client/accounting.ts","../src/llm-client/errors.ts","../src/llm-client/json.ts","../src/llm-client/resilience.ts","../src/analyst/policy-edit.ts","../src/capability-headroom.ts","../src/cost-tracker.ts","../src/detectors/index.ts","../src/error-count-extractor.ts","../src/knowledge/types.ts","../src/leaderboard.ts","../src/paired-delta-test.ts","../src/partition-held-out.ts","../src/product-benchmark/export.ts","../src/product-benchmark/index.ts","../src/runtime-trajectory.ts","../src/active-learning.ts","../src/bounded-process.ts","../src/command-runner.ts","../src/discover-personas.ts","../src/improvement-verdict.ts","../src/propose-review.ts","../src/reflective-mutation.ts","../src/eval-trace-store.ts","../src/integrity/preflight.ts","../src/model-seats.ts","../src/prompt-registry.ts","../src/reference-replay.ts","../src/steering.ts","../src/run-score.ts","../src/steering-optimizer.ts","../src/counterfactual.ts","../src/scorecard.ts","../src/trace-contracts/types.ts","../src/trace-contracts/builder.ts","../src/trace-contracts/evaluate.ts","../src/trace-contracts/explain.ts","../src/trace-contracts/spec.ts","../src/action-policy.ts","../src/contamination-guard.ts","../src/deploy-gate-layer.ts","../src/hidden-criteria-grading.ts","../src/integrity/single-backend.ts","../src/intent-match-judge.ts","../src/judge-ensemble.ts","../src/judge-retry.ts","../src/judge-panel.ts","../src/keyword-coverage-judge.ts","../src/oracle.ts","../src/paired-promotion-power.ts","../src/treatment-gate.ts","../src/verdict-cache.ts","../src/profile/baselines.ts","../src/profile/index.ts","../src/budget-guard.ts","../src/client.ts","../src/control-runtime.ts","../src/control-runtime/policy.ts","../src/knowledge/readiness.ts","../src/metrics.ts","../src/anti-slop.ts","../src/sandbox-assertions.ts"],"mappings":"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"}