@tangle-network/agent-eval 0.173.2 → 0.174.0

package/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
+## [0.174.0] — 2026-09-05
+
+### Changed
+
+- `selfImprove({ method })` executes the method directly and measures its selected surface on final cases.
+  It returns `SelfImproveMethodResult` with `mode: 'method'`, actual `raw.method` evidence, and `tangle.method-improvement` provenance.
+  It does not expose native `raw.generations` or `generationsExplored`.
+- `selfImprove({ proposer })` returns `SelfImproveProposerResult` with `mode: 'proposer'` and the existing native history.
+  `SelfImproveResult` is the union; consumers must narrow by `mode` before reading fields specific to one mode.
+- Method results with deferred holdout return `baseline: null`, `winner.compositeMean: null`, and no lift.
+  Method `cost` includes reported search and final spending; `ledgerCost` retains the actual receipt breakdown.
+- Premeasured native baselines must match the evaluator manifest.
+  Use `surfaceDispatchRef(baselineSurface, dispatchRef)` when creating the baseline campaign.
+  See [the result and cache contracts](docs/campaign-proposers.md#read-an-improvement-result).
+
+### Fixed
+
+- Complete methods can select the unchanged baseline without triggering native duplicate-candidate rejection.
+- Native ranking cannot override a complete method's selected winner or repeat its train and selection evaluations.
+- Method-reported spend and incomplete accounting remain in the total without duplicating metered costs.
+  Both improvement and method comparison reconcile each method's report against its attributed ledger receipts.
+- Final method comparisons reject missing replicas before averaging surviving scores.
+- Native search and final caches bind the candidate's surface content to execution identity.
+- Premeasured baselines from a different judge revision are refused before candidate execution.
+- Native candidate history reports `ci95: null` when uncertainty was not estimated.
+- An unchanged baseline's shared campaign contributes once to result analysis, including execution count, tokens, and cost.
+- `BehaviorExplorer` uses observed scores when assigning the next round's evaluations by behavior cell.
+  Scenario records retain their individual identities; allocation uses the pooled cell identity.
+
+---
+
+## [0.173.3] — 2026-09-04
+
+### Fixed
+
+- The Runtime supervisor reader now treats `spawned.ownedTreeRoot` as the exclusive nested tree when present.
+  It rejects an additional child-id tree and any descendant spawn outside its parent's owned tree.
+
+---
+
 ## [0.173.2] — 2026-09-04
 
 ### Fixed

package/dist/{proposal-findings-bko3GGy-.js → abort-signal-CtzAM_sJ.js}

@@ -1,13 +1,4 @@
 import { z } from "zod";
-//#region src/abort-signal.ts
-/** Combine active cancellation sources without wrapping a single source. */
-function combineAbortSignals(...signals) {
-	const active = [...new Set(signals.filter((signal) => signal !== void 0))];
-	if (active.length === 0) return void 0;
-	if (active.length === 1) return active[0];
-	return AbortSignal.any(active);
-}
-//#endregion
 //#region src/analyst/proposal-findings.ts
 const ProposalFindingSchema = z.object({
 	schema_version: z.literal("1.0.0"),
@@ -64,6 +55,15 @@ function findingLabel(finding, index) {
 	return typeof id === "string" && id.length > 0 ? id : `index ${index}`;
 }
 //#endregion
-export { isProposalFinding as n, combineAbortSignals as r, assertProposalFindings as t };
+//#region src/abort-signal.ts
+/** Combine active cancellation sources without wrapping a single source. */
+function combineAbortSignals(...signals) {
+	const active = [...new Set(signals.filter((signal) => signal !== void 0))];
+	if (active.length === 0) return void 0;
+	if (active.length === 1) return active[0];
+	return AbortSignal.any(active);
+}
+//#endregion
+export { assertProposalFindings as n, isProposalFinding as r, combineAbortSignals as t };
 
-//# sourceMappingURL=proposal-findings-bko3GGy-.js.map
+//# sourceMappingURL=abort-signal-CtzAM_sJ.js.map

package/dist/abort-signal-CtzAM_sJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort-signal-CtzAM_sJ.js","names":[],"sources":["../src/analyst/proposal-findings.ts","../src/abort-signal.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { ProposalFinding } from './types'\n\nconst ProposalFindingSchema = z\n  .object({\n    schema_version: z.literal('1.0.0'),\n    finding_id: z.string().min(1),\n    analyst_id: z.string().min(1),\n    produced_at: z.string().min(1),\n    severity: z.enum(['critical', 'high', 'medium', 'low', 'info']),\n    area: z.string().min(1),\n    claim: z.string().min(1),\n    rationale: z.string().optional(),\n    evidence_refs: z.array(\n      z\n        .object({\n          kind: z.enum(['span', 'event', 'artifact', 'finding', 'metric']),\n          uri: z.string().min(1),\n          excerpt: z.string().optional(),\n        })\n        .strict(),\n    ),\n    recommended_action: z.string().optional(),\n    validation_plan: z.string().optional(),\n    confidence: z.number().min(0).max(1),\n    subject: z.string().optional(),\n    derived_from_judge: z.boolean().optional(),\n    metadata: z.record(z.string(), z.unknown()).optional(),\n    proposal_origin: z.enum(['search', 'production']),\n  })\n  .strict() satisfies z.ZodType<ProposalFinding>\n\n/** True when a finding names a source candidate generation may learn from. */\nexport function isProposalFinding(finding: unknown): finding is ProposalFinding {\n  return ProposalFindingSchema.safeParse(finding).success\n}\n\n/**\n * Reject findings whose source has not been explicitly admitted for candidate\n * generation. Search feedback and observed production behavior are allowed;\n * final evaluation data has no allowed origin.\n */\nexport function assertProposalFindings(\n  findings: unknown,\n  context = 'proposal findings',\n): ReadonlyArray<ProposalFinding> {\n  if (!Array.isArray(findings)) {\n    throw new TypeError(`${context}: expected an array`)\n  }\n  const rejected = findings.flatMap((finding, index) =>\n    isProposalFinding(finding) ? [] : [findingLabel(finding, index)],\n  )\n  if (rejected.length > 0) {\n    throw new Error(\n      `${context}: every finding must match AnalystFinding and declare ` +\n        `proposal_origin as search or production. ` +\n        `Rejected findings: [${rejected.join(', ')}].`,\n    )\n  }\n  return findings as ReadonlyArray<ProposalFinding>\n}\n\nfunction findingLabel(finding: unknown, index: number): string {\n  if (typeof finding !== 'object' || finding === null) return `index ${index}`\n  const id = (finding as { finding_id?: unknown }).finding_id\n  return typeof id === 'string' && id.length > 0 ? id : `index ${index}`\n}\n","/** Combine active cancellation sources without wrapping a single source. */\nexport function combineAbortSignals(\n  ...signals: Array<AbortSignal | undefined>\n): AbortSignal | undefined {\n  const active = [\n    ...new Set(signals.filter((signal): signal is AbortSignal => signal !== undefined)),\n  ]\n  if (active.length === 0) return undefined\n  if (active.length === 1) return active[0]\n  return AbortSignal.any(active)\n}\n"],"mappings":";;AAGA,MAAM,wBAAwB,EAC3B,OAAO;CACN,gBAAgB,EAAE,QAAQ,OAAO;CACjC,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC5B,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC5B,aAAa,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC7B,UAAU,EAAE,KAAK;EAAC;EAAY;EAAQ;EAAU;EAAO;CAAM,CAAC;CAC9D,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACtB,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACvB,WAAW,EAAE,OAAO,CAAC,CAAC,SAAS;CAC/B,eAAe,EAAE,MACf,EACG,OAAO;EACN,MAAM,EAAE,KAAK;GAAC;GAAQ;GAAS;GAAY;GAAW;EAAQ,CAAC;EAC/D,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACrB,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS;CAC/B,CAAC,CAAC,CACD,OAAO,CACZ;CACA,oBAAoB,EAAE,OAAO,CAAC,CAAC,SAAS;CACxC,iBAAiB,EAAE,OAAO,CAAC,CAAC,SAAS;CACrC,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;CACnC,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS;CAC7B,oBAAoB,EAAE,QAAQ,CAAC,CAAC,SAAS;CACzC,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;CACrD,iBAAiB,EAAE,KAAK,CAAC,UAAU,YAAY,CAAC;AAClD,CAAC,CAAC,CACD,OAAO;;AAGV,SAAgB,kBAAkB,SAA8C;CAC9E,OAAO,sBAAsB,UAAU,OAAO,CAAC,CAAC;AAClD;;;;;;AAOA,SAAgB,uBACd,UACA,UAAU,qBACsB;CAChC,IAAI,CAAC,MAAM,QAAQ,QAAQ,GACzB,MAAM,IAAI,UAAU,GAAG,QAAQ,oBAAoB;CAErD,MAAM,WAAW,SAAS,SAAS,SAAS,UAC1C,kBAAkB,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,SAAS,KAAK,CAAC,CACjE;CACA,IAAI,SAAS,SAAS,GACpB,MAAM,IAAI,MACR,GAAG,QAAQ,qHAEc,SAAS,KAAK,IAAI,EAAE,GAC/C;CAEF,OAAO;AACT;AAEA,SAAS,aAAa,SAAkB,OAAuB;CAC7D,IAAI,OAAO,YAAY,YAAY,YAAY,MAAM,OAAO,SAAS;CACrE,MAAM,KAAM,QAAqC;CACjD,OAAO,OAAO,OAAO,YAAY,GAAG,SAAS,IAAI,KAAK,SAAS;AACjE;;;;ACjEA,SAAgB,oBACd,GAAG,SACsB;CACzB,MAAM,SAAS,CACb,GAAG,IAAI,IAAI,QAAQ,QAAQ,WAAkC,WAAW,KAAA,CAAS,CAAC,CACpF;CACA,IAAI,OAAO,WAAW,GAAG,OAAO,KAAA;CAChC,IAAI,OAAO,WAAW,GAAG,OAAO,OAAO;CACvC,OAAO,YAAY,IAAI,MAAM;AAC/B"}

package/dist/adapters/http.d.ts

@@ -1,5 +1,5 @@
-import { R as Scenario, d as DispatchContext, f as DispatchFn } from "../types-Ba5UQyVD.js";
-import "../index-BQqOjerE.js";
+import { R as Scenario, d as DispatchContext, f as DispatchFn } from "../types-BJz2CPTM.js";
+import "../index-BTrx5s8m.js";
 //#region src/adapters/http.d.ts
 interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
   /** Static endpoint URL. Mutually exclusive with `resolveUrl`. */

package/dist/agent-profile-_xPxqVJt.d.ts

@@ -0,0 +1,488 @@
+import { b as CustomTokenPricing, g as CostReceiptInput } from "./cost-ledger-DbQdN3nO.js";
+import { c as AnalystRunInputs, f as AnalystUsageReceipt, i as AnalystFinding, p as EvidenceRef, w as TraceAnalysisStore } from "./types-DN2WdT5S.js";
+import { h as ChatResponse, m as ChatRequest } from "./types-gvRsyJLh.js";
+import { c as RegistryRunOpts, n as AnalystRegistry } from "./registry-7pOUBrtX.js";
+import { AgentProfile, AgentProfile as AgentProfile$1, HarnessType, HarnessType as HarnessType$1 } from "@tangle-network/agent-interface";
+//#region src/campaign/external-optimizer-contracts.d.ts
+interface ExternalOptimizerProcessLimits {
+  /** Maximum serialized input written for the child process. */
+  maxInputBytes: number;
+  /** Maximum JSON result read from the child process. */
+  maxResultBytes: number;
+  /** Maximum stdout or stderr characters retained for diagnostics. */
+  maxOutputChars: number;
+}
+declare const DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS: Readonly<ExternalOptimizerProcessLimits>;
+interface ExternalOptimizerCallbackLimits {
+  /** Maximum serialized request accepted by the loopback callback. */
+  maxRequestBytes: number;
+  /** Maximum serialized response returned by the loopback callback. */
+  maxResponseBytes: number;
+}
+declare const DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS: Readonly<ExternalOptimizerCallbackLimits>;
+interface ExternalOptimizerRunnerCommand {
+  command?: string;
+  args?: readonly string[];
+  env?: NodeJS.ProcessEnv;
+  /** Child-process resource limits. Omitted fields use finite defaults. */
+  limits?: Partial<ExternalOptimizerProcessLimits>;
+}
+type ExternalOptimizerResumeMode = 'never' | 'if-compatible' | 'required';
+type ExternalTextCandidate = string | Record<string, string>;
+interface ExternalTextEvaluationRequest {
+  candidate: ExternalTextCandidate;
+  exampleId: string;
+}
+declare function resolveExternalOptimizerProcessLimits(value: Partial<ExternalOptimizerProcessLimits> | undefined, label?: string): ExternalOptimizerProcessLimits;
+declare function resolveExternalOptimizerCallbackLimits(value: Partial<ExternalOptimizerCallbackLimits> | undefined, label?: string): ExternalOptimizerCallbackLimits;
+type DeepReadonly<T> = T extends ((...args: never[]) => unknown) ? T : T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T;
+/** Provider-neutral request parsed once from the optimizer's loopback protocol. */
+type ExternalOptimizerChatRequest = DeepReadonly<Omit<ChatRequest, 'model'> & {
+  model: string;
+}>;
+type ExternalOptimizerEndpointFormat = 'chat-completions' | 'responses' | 'anthropic-messages';
+/** One exact model request admitted by the loopback proxy. */
+interface ExternalOptimizerModelCallRequest {
+  /** Stable identity allocated by the cost ledger for this paid call. */
+  readonly callId: string;
+  /** Deeply immutable canonical request; HTTP protocol fields never cross this boundary. */
+  readonly request: ExternalOptimizerChatRequest;
+  /** Child response shape, when the execution owner needs to retain it as evidence. */
+  readonly endpointFormat?: ExternalOptimizerEndpointFormat;
+  readonly signal: AbortSignal;
+}
+/** Runtime-owned result for one admitted optimizer-model call. */
+type ExternalOptimizerModelCallResult = {
+  readonly succeeded: true;
+  /** Canonical response encoded back into the child's protocol by Agent Eval. */
+  readonly response: ChatResponse;
+  /**
+   * Canonical measured usage/cost input retained by Agent Eval's cost ledger.
+   * `inputTokens` is the non-cached portion, `cachedTokens` is the cache-read
+   * portion, and response `promptTokens` equals their sum. Cache-write tokens
+   * remain a separately billed class and are never silently added to that total.
+   */
+  readonly receipt: CostReceiptInput;
+  /** Opaque, finite JSON proof of the exact execution retained in provenance. */
+  readonly execution: unknown;
+} | {
+  readonly succeeded: false;
+  /** Public failure text safe to retain and return to the child process. */
+  readonly error: string;
+  /** Usage/cost state for the failed Runtime call. Unknown values stay unknown. */
+  readonly receipt: CostReceiptInput;
+  /** Opaque, finite JSON proof of the failed exact execution. */
+  readonly execution: unknown;
+};
+/**
+ * Execution-neutral model-call seam for an external optimizer.
+ *
+ * The package that owns execution implements this with its exact execution
+ * path. For Discovery that owner is Runtime and the identity is an
+ * AgentProfile. The loopback proxy owns request validation, limits, response
+ * bounds, and cost-ledger recording. Once invoked, the callback must resolve
+ * with one success/failure result. Rejecting loses the execution record and
+ * therefore fails the optimizer attempt.
+ */
+type ExternalOptimizerModelCall = (request: ExternalOptimizerModelCallRequest) => Promise<ExternalOptimizerModelCallResult>;
+/** One opaque Runtime execution record retained for one admitted model call. */
+type ExternalOptimizerModelExecutionObservation = {
+  readonly sequence: number;
+  readonly callId: string;
+  readonly callRef: string;
+  readonly path: '/v1/chat/completions' | '/v1/responses' | '/v1/messages';
+  readonly model: string;
+  readonly succeeded: true;
+  readonly responseStatus: number;
+  readonly execution: unknown;
+} | {
+  readonly sequence: number;
+  readonly callId: string;
+  readonly callRef: string;
+  readonly path: '/v1/chat/completions' | '/v1/responses' | '/v1/messages';
+  readonly model: string;
+  readonly succeeded: false;
+  readonly error: string;
+  readonly execution: unknown;
+};
+type ExternalOptimizerEvaluationRefusalReason = 'invalid-request' | 'evaluation-limit' | 'evaluation-failed';
+/**
+ * Durable callback-side record of every candidate submitted for scoring,
+ * scored task, and callback refusal. Optimizer-internal proposals that never
+ * reach this callback are outside this record's scope.
+ */
+type ExternalOptimizerEvaluationObservation = {
+  readonly kind: 'proposal';
+  readonly sequence: number;
+  readonly candidate: ExternalTextCandidate;
+  readonly candidateHash: string;
+} | {
+  readonly kind: 'evaluation';
+  readonly sequence: number;
+  readonly candidate: ExternalTextCandidate;
+  readonly candidateHash: string;
+  readonly exampleId: string;
+  /** One-based accepted evaluation number for this optimizer attempt. */
+  readonly evaluationNumber: number;
+  readonly response: unknown;
+} | {
+  readonly kind: 'refusal';
+  readonly sequence: number;
+  readonly reason: ExternalOptimizerEvaluationRefusalReason;
+  readonly candidate?: ExternalTextCandidate;
+  readonly candidateHash?: string;
+  readonly exampleId?: string;
+};
+interface ExternalOptimizerModelBudget {
+  /** Optional optimizer-model spend ceiling, independent of task-evaluation spend. */
+  maxCostUsd?: number;
+  /** Maximum calls into the execution owner; owner-internal retries are reported there. */
+  maxRequests: number;
+  /** Reject a request body above this byte count. */
+  maxRequestBytes: number;
+  /** Reject a provider response above this byte count. */
+  maxResponseBytes: number;
+  /** Reject a request asking the provider for more output tokens. */
+  maxOutputTokensPerRequest: number;
+  /**
+   * Reasoning tokens a single response may bill beyond its completion limit.
+   *
+   * A reasoning model bounds only the completion by `max_tokens` and bills
+   * thinking on top, so a reservation sized to the completion alone is always
+   * too small and the ledger refuses the real charge. Callers that route a
+   * reasoning model declare its thinking budget here; the reservation covers
+   * it and a response exceeding it still fails loudly. Default: 0.
+   */
+  maxReasoningTokensPerRequest?: number;
+  /**
+   * Optional rates used to estimate cost when the provider omits a valid
+   * `usage.cost`. Omit when billed USD is unknown; catalog estimates are not
+   * enforcement evidence.
+   */
+  pricing?: CustomTokenPricing;
+  /** Per-provider-request deadline. Default: 300,000 ms. */
+  requestTimeoutMs?: number;
+}
+/** Per-wire request accounting for the loopback proxy. */
+interface ExternalOptimizerWireCounts {
+  /** Execution-owner calls admitted on this wire, including failures. */
+  requestAttempts: number;
+  /** Successful 2xx responses recorded on this wire. */
+  successfulCompletions: number;
+}
+//#endregion
+//#region src/analyst/benchmark-scoring.d.ts
+declare function scoreAnalystFindings(testCase: Pick<AnalystBenchmarkCase, 'id' | 'expectedIssues' | 'labeledEvidence'>, findings: readonly AnalystFinding[]): AnalystFindingScore;
+//#endregion
+//#region src/analyst/benchmark.d.ts
+interface AnalystEvidenceExpectation {
+  uri: string;
+  kind?: EvidenceRef['kind'];
+}
+interface AnalystIssueExpectation {
+  id: string;
+  findingIds?: readonly string[];
+  areas?: readonly string[];
+  subjects?: readonly string[];
+  evidence?: readonly AnalystEvidenceExpectation[];
+  evidenceMode?: 'any' | 'all';
+  /** Exact evidence location for the first unrecoverable or causal step. */
+  criticalEvidence?: readonly AnalystEvidenceExpectation[];
+}
+type AnalystBenchmarkLabelState = 'positive' | 'trusted-negative' | 'unlabeled';
+interface AnalystBenchmarkCase<TInput = unknown> {
+  id: string;
+  /** Independent source unit used for resampling, such as a task or incident. */
+  clusterId: string;
+  /** Whether labels prove an issue, prove no issue, or leave the outcome unknown. */
+  labelState: AnalystBenchmarkLabelState;
+  input: TInput;
+  expectedIssues: readonly AnalystIssueExpectation[];
+  /** Complete set of labeled locations used to measure label-location agreement. */
+  labeledEvidence?: readonly AnalystEvidenceExpectation[];
+  tags?: readonly string[];
+  metadata?: Record<string, unknown>;
+}
+interface AnalystFindingScore {
+  expectedIssueCount: number;
+  matchedIssueIds: string[];
+  missedIssueIds: string[];
+  supportedFindingIndexes: number[];
+  unsupportedFindingIndexes: number[];
+  unlabeledEvidence: EvidenceRef[];
+  issueRecall: number;
+  findingPrecision: number;
+  f1: number;
+  criticalStepAccuracy: number | null;
+  /** Share of findings that cite at least one evidence location. */
+  citationCoverage: number | null;
+  /** Share of citations that include a non-empty source excerpt. */
+  citationExcerptCoverage: number | null;
+  /** Share of citations that agree with a labeled case location. */
+  citationLabelAgreement: number | null;
+  predictionOnLabelEmptyCase: boolean;
+}
+interface AnalystEvidenceResolutionError {
+  evidence: EvidenceRef;
+  class: string;
+  message: string;
+}
+interface AnalystEvidenceResolution {
+  checked: number;
+  resolved: number;
+  unresolvedEvidence: EvidenceRef[];
+  errors: AnalystEvidenceResolutionError[];
+  /** Null when no citations were checked or any resolution attempt failed. */
+  validity: number | null;
+}
+type AnalystEvidenceResolver<TInput = unknown> = (input: {
+  caseId: string;
+  caseInput: TInput;
+  evidence: EvidenceRef;
+  signal?: AbortSignal;
+}) => boolean | Promise<boolean>;
+/**
+ * Resolve canonical `trace://<trace>/span/<span>` evidence against a trace store.
+ * Other evidence kinds and URI schemes require a caller-supplied resolver.
+ */
+declare function traceStoreEvidenceResolver<TInput>(getStore: (input: TInput) => TraceAnalysisStore): AnalystEvidenceResolver<TInput>;
+interface AnalystBenchmarkOutput {
+  findings: readonly AnalystFinding[];
+  usage?: AnalystUsageReceipt;
+  metadata?: Record<string, unknown>;
+  /**
+   * End-to-end duration measured by an external runner before import.
+   * Use null when the source explicitly did not capture duration.
+   */
+  observedLatencyMs?: number | null;
+  /** Marks a completed transport as a failed analyst run while retaining usage and metadata. */
+  error?: AnalystBenchmarkError;
+}
+interface AnalystBenchmarkError {
+  class: string;
+  message: string;
+  code?: string;
+  status?: number;
+}
+interface AnalystBenchmarkRunner<TInput = unknown> {
+  id: string;
+  analyze(input: TInput, context: {
+    caseId: string;
+    repetition: number;
+    signal?: AbortSignal;
+  }): AnalystBenchmarkOutput | Promise<AnalystBenchmarkOutput>;
+}
+interface AnalystBenchmarkObservation {
+  runnerId: string;
+  caseId: string;
+  clusterId: string;
+  labelState: AnalystBenchmarkLabelState;
+  repetition: number;
+  executionIndex: number;
+  latencyMs: number | null;
+  latencySource: 'benchmark-clock' | 'runner-reported' | 'uncaptured';
+  findings: readonly AnalystFinding[];
+  score: AnalystFindingScore;
+  evidenceResolution?: AnalystEvidenceResolution;
+  caseTags: readonly string[];
+  caseMetadata?: Record<string, unknown>;
+  usage?: AnalystUsageReceipt;
+  runnerMetadata?: Record<string, unknown>;
+  error?: AnalystBenchmarkError;
+}
+interface AnalystLatencyDistribution {
+  min: number;
+  mean: number;
+  p50: number;
+  p95: number;
+  max: number;
+}
+interface AnalystBenchmarkSummary {
+  runnerId: string;
+  plannedRuns: number;
+  completedRuns: number;
+  failedRuns: number;
+  issueBearingRuns: number;
+  trustedNegativeRuns: number;
+  unlabeledRuns: number;
+  /** Pooled across all labeled issues and findings. */
+  issueRecall: number | null;
+  /** Pooled across all labeled issues and findings. */
+  findingPrecision: number | null;
+  /** Harmonic mean of the pooled precision and recall. */
+  f1: number | null;
+  /** Mean of per-case recall over issue-bearing runs. */
+  macroIssueRecall: number | null;
+  /** Mean of per-case precision over issue-bearing runs. */
+  macroFindingPrecision: number | null;
+  /** Mean of per-case F1 over issue-bearing runs. */
+  macroF1: number | null;
+  criticalStepAccuracy: number | null;
+  citationCoverage: number | null;
+  citationExcerptCoverage: number | null;
+  citationLabelAgreement: number | null;
+  citationResolution: number | null;
+  citationResolutionUnknownRuns: number;
+  unresolvedCitations: number;
+  citationResolutionErrors: number;
+  trustedNegativeFalsePositiveRate: number | null;
+  trustedNegativeFailureRate: number | null;
+  unlabeledPredictionRate: number | null;
+  unlabeledFailureRate: number | null;
+  /** Primary repeatability measure over complete finding identity and evidence. */
+  predictionAgreement: number | null;
+  /** Repeated cases contributing equally to predictionAgreement. */
+  predictionAgreementCases: number;
+  /** Secondary repeatability detail over matched expected labels. */
+  matchedLabelAgreement: number | null;
+  /** Positive repeated cases contributing equally to matchedLabelAgreement. */
+  matchedLabelAgreementCases: number;
+  latencyMs: AnalystLatencyDistribution | null;
+  benchmarkClockLatencyRuns: number;
+  runnerReportedLatencyRuns: number;
+  latencyUnknownRuns: number;
+  calls: number;
+  callsUnknownRuns: number;
+  inputTokens: number;
+  outputTokens: number;
+  reasoningTokens: number;
+  cachedTokens: number;
+  cacheWriteTokens: number;
+  tokenUsageUnknownRuns: number;
+  reasoningTokenUsageUnknownRuns: number;
+  cachedTokenUsageUnknownRuns: number;
+  cacheWriteTokenUsageUnknownRuns: number;
+  knownCostUsd: number;
+  costUnknownRuns: number;
+}
+interface AnalystBenchmarkDatasetRef {
+  id: string;
+  revision: string;
+  split?: string;
+}
+interface AnalystBenchmarkDescriptor {
+  id?: string;
+  dataset?: AnalystBenchmarkDatasetRef;
+  command?: string;
+  environment?: Record<string, string>;
+  metadata?: Record<string, unknown>;
+}
+interface AnalystBenchmarkProvenance extends AnalystBenchmarkDescriptor {
+  startedAt: string;
+  endedAt: string;
+  caseCount: number;
+  runnerIds: string[];
+  repetitions: number;
+  maxConcurrency: number;
+  runnerOrderSeed: number;
+}
+interface AnalystBenchmarkResult {
+  provenance: AnalystBenchmarkProvenance;
+  observations: AnalystBenchmarkObservation[];
+  summaries: AnalystBenchmarkSummary[];
+}
+interface RunAnalystBenchmarkOptions<TInput> {
+  cases: readonly AnalystBenchmarkCase<TInput>[];
+  runners: readonly AnalystBenchmarkRunner<TInput>[];
+  repetitions?: number;
+  maxConcurrency?: number;
+  runnerOrderSeed?: number;
+  resolveEvidence?: AnalystEvidenceResolver<TInput>;
+  benchmark?: AnalystBenchmarkDescriptor;
+  /** Previously persisted rows. Exact case, runner, repetition, and execution identities are required. */
+  initialObservations?: readonly AnalystBenchmarkObservation[];
+  onObservation?: (observation: AnalystBenchmarkObservation) => void | Promise<void>;
+  signal?: AbortSignal;
+}
+declare function runAnalystBenchmark<TInput>(options: RunAnalystBenchmarkOptions<TInput>): Promise<AnalystBenchmarkResult>;
+declare function registryBenchmarkRunner(options: {
+  id: string;
+  registry: AnalystRegistry;
+  runOptions?: Omit<RegistryRunOpts, 'signal'>;
+  /** Count any selected analyst failure as a failed benchmark run. */
+  failOnAnalystFailure?: boolean;
+}): AnalystBenchmarkRunner<AnalystRunInputs>;
+//#endregion
+//#region src/agent-profile.d.ts
+/**
+ * The agentic coding harnesses an eval sweeps by default — the ones we care about
+ * ranking. This is the SINGLE source of that list; consumers import it instead of
+ * re-declaring their own (a re-declared list is how the fleet drifts). Pass an
+ * explicit `harnesses` (e.g. `harnessTypeSchema.options` for literally every known
+ * harness) to widen beyond these.
+ */
+declare const CODING_HARNESSES: readonly HarnessType[];
+interface ProfileAxisSpec {
+  /** The domain profile to sweep. Its prompt/tools/skills are held fixed; only the
+   *  harness and model vary. `model.default` is the fallback model. */
+  base: AgentProfile;
+  /** Harnesses to cross. Default: {@link CODING_HARNESSES}. */
+  harnesses?: readonly HarnessType[];
+  /** Models to cross. Default: `[base.model.default]` — one model, i.e. today's
+   *  single-model behaviour, so omitting this never changes an existing run. */
+  models?: readonly string[];
+  /** Force every (harness, model) pair verbatim, even ones the harness can't run —
+   *  for deliberately testing failure modes. Default (false): SNAP instead — a
+   *  vendor-locked harness runs only the swept models in its family, or its native
+   *  default when it supports none, so no harness is dropped and none gets a
+   *  guaranteed-failing foreign-model cell. */
+  keepIncompatible?: boolean;
+}
+/** Model sentinel for a vendor-locked harness that supports none of the swept models:
+ *  it carries no provider prefix, so `harnessSupportsModel` accepts it and the harness
+ *  resolves it to its own native default model at runtime (e.g. kimi-code → its Kimi
+ *  model). Lets `expandProfileAxes` snap-instead-of-drop without a per-harness flagship
+ *  table that would rot as router catalogs change. */
+declare const HARNESS_NATIVE_MODEL = "default";
+/**
+ * Expand a base profile across the harness × model matrix into the `AgentProfile[]`
+ * that `runProfileMatrix` / `selfImprove` score — the ONE place "which harnesses ×
+ * which models do we evaluate" lives, so no product hand-rolls its own harness list
+ * or column→profile mapping (the pattern that let those copies drift and silently
+ * break the harness pivot).
+ *
+ * Each cell clones `base`, sets the canonical top-level `harness` and `model.default`,
+ * and stamps `metadata.harness` + `metadata.harnessModel` for matrix grouping. Both
+ * metadata fields are hash-bearing, so every cell gets a distinct `agentProfileId` row
+ * and results join back by harness/model via {@link harnessAxisOf} with no
+ * hand-recomputed key. A vendor-locked harness snaps to its family's swept models — or
+ * its native default ({@link HARNESS_NATIVE_MODEL}) when it supports none — so every
+ * requested harness runs; `keepIncompatible` forces every pair verbatim.
+ *
+ * Omit `harnesses`/`models` to sweep the full default set — the "turn it on for
+ * everything we care about" switch, identical in shape whether one harness or all.
+ */
+declare function expandProfileAxes(spec: ProfileAxisSpec): AgentProfile[];
+/**
+ * Read the (harness, model) a matrix cell ran under, off a profile or a result row's
+ * profile — the join-back for a `byHarness` pivot. Returns undefined when the profile
+ * wasn't produced by {@link expandProfileAxes}. Callers group `result.byProfile` by
+ * this instead of recomputing an id (recomputing the wrong key is what broke the pivot
+ * in the hand-rolled copies).
+ */
+declare function harnessAxisOf(profile: Pick<AgentProfile, 'metadata'>): {
+  harness: HarnessType;
+  model: string;
+} | undefined;
+/**
+ * Collision-resistant, path-safe, human-readable profile id for eval artifacts.
+ * Scorecard joins still use `agentProfileHash`; this id is for run ids, matrix
+ * keys, and directory names where two profiles must not collapse onto one row.
+ * The suffix is the first 64 bits of the behaviour hash, enough for ordinary
+ * eval matrices while keeping filenames readable.
+ */
+declare function agentProfileId(profile: AgentProfile): string;
+/**
+ * Deterministic behaviour identity for the canonical
+ * `@tangle-network/agent-interface` AgentProfile.
+ *
+ * `name` and `description` are labels and do not affect the hash. Profile
+ * `version`, prompt, model hints, tools, resources, hooks, modes, permissions,
+ * and extensions do affect the hash. Resource array order is hash-bearing
+ * because mount order can change agent behaviour. Undefined fields are treated
+ * as absent; explicit `null` fields remain hash-bearing.
+ */
+declare function agentProfileHash(profile: AgentProfile): string;
+//#endregion
+export { runAnalystBenchmark as A, ExternalOptimizerModelBudget as B, AnalystEvidenceResolutionError as C, AnalystLatencyDistribution as D, AnalystIssueExpectation as E, ExternalOptimizerCallbackLimits as F, ExternalOptimizerProcessLimits as G, ExternalOptimizerModelCallRequest as H, ExternalOptimizerChatRequest as I, ExternalOptimizerWireCounts as J, ExternalOptimizerResumeMode as K, ExternalOptimizerEndpointFormat as L, scoreAnalystFindings as M, DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS as N, RunAnalystBenchmarkOptions as O, DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS as P, resolveExternalOptimizerProcessLimits as Q, ExternalOptimizerEvaluationObservation as R, AnalystEvidenceResolution as S, AnalystFindingScore as T, ExternalOptimizerModelCallResult as U, ExternalOptimizerModelCall as V, ExternalOptimizerModelExecutionObservation as W, ExternalTextEvaluationRequest as X, ExternalTextCandidate as Y, resolveExternalOptimizerCallbackLimits as Z, AnalystBenchmarkProvenance as _, ProfileAxisSpec as a, AnalystBenchmarkSummary as b, expandProfileAxes as c, AnalystBenchmarkDatasetRef as d, AnalystBenchmarkDescriptor as f, AnalystBenchmarkOutput as g, AnalystBenchmarkObservation as h, HarnessType$1 as i, traceStoreEvidenceResolver as j, registryBenchmarkRunner as k, harnessAxisOf as l, AnalystBenchmarkLabelState as m, CODING_HARNESSES as n, agentProfileHash as o, AnalystBenchmarkError as p, ExternalOptimizerRunnerCommand as q, HARNESS_NATIVE_MODEL as r, agentProfileId as s, AgentProfile$1 as t, AnalystBenchmarkCase as u, AnalystBenchmarkResult as v, AnalystEvidenceResolver as w, AnalystEvidenceExpectation as x, AnalystBenchmarkRunner as y, ExternalOptimizerEvaluationRefusalReason as z };
+//# sourceMappingURL=agent-profile-_xPxqVJt.d.ts.map

package/dist/agent-profile-_xPxqVJt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-profile-_xPxqVJt.d.ts","names":[],"sources":["../src/campaign/external-optimizer-contracts.ts","../src/analyst/benchmark-scoring.ts","../src/analyst/benchmark.ts","../src/agent-profile.ts"],"mappings":"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"}

package/dist/analyst/index.d.ts

@@ -1,15 +1,13 @@
 import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-DbQdN3nO.js";
 import { I as TraceAnalystSpan, _ as ProposalFinding, a as AnalystInputKind, b as makeFinding, c as AnalystRunInputs, d as AnalystSeverity, f as AnalystUsageReceipt, g as ExecutionProbeRequest, h as ExecutionProbeOutcome, i as AnalystFinding, l as AnalystRunResult, m as ExecutionProbe, n as AnalystContext, o as AnalystRequirements, p as EvidenceRef, r as AnalystCost, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary, v as ProposalFindingOrigin, w as TraceAnalysisStore, x as makeProposalFinding, y as computeFindingId } from "../types-DN2WdT5S.js";
 import { S as createChatClient, _ as CreateChatClientOpts, b as OpenAiCompatibleTransportOpts, f as ChatCallOpts, g as ChatTransport, h as ChatResponse, m as ChatRequest, p as ChatClient, v as CustomTransportOpts, x as SandboxSdkTransportOpts, y as MockTransportOpts } from "../types-gvRsyJLh.js";
-import { f as ExternalOptimizerModelExecutionObservation, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall } from "../external-optimizer-contracts-CQCpyrIL.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-BKwc8bN5.js";
+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-_xPxqVJt.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-BKOEILRP.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-7pOUBrtX.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-DhFir3Ys.js";
-import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-groups-Cp4Xdzrp.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-D0Db5X-4.js";
-import { C as scoreAnalystFindings, S as traceStoreEvidenceResolver, _ as AnalystIssueExpectation, a as AnalystBenchmarkLabelState, b as registryBenchmarkRunner, c as AnalystBenchmarkProvenance, d as AnalystBenchmarkSummary, f as AnalystEvidenceExpectation, g as AnalystFindingScore, h as AnalystEvidenceResolver, i as AnalystBenchmarkError, l as AnalystBenchmarkResult, m as AnalystEvidenceResolutionError, n as AnalystBenchmarkDatasetRef, o as AnalystBenchmarkObservation, p as AnalystEvidenceResolution, r as AnalystBenchmarkDescriptor, s as AnalystBenchmarkOutput, t as AnalystBenchmarkCase, u as AnalystBenchmarkRunner, v as AnalystLatencyDistribution, x as runAnalystBenchmark, y as RunAnalystBenchmarkOptions } from "../benchmark-BjLGkfnN.js";
-import { t as AgentProfile } from "../agent-profile-B9_GGsG8.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-FfNzaUHV.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-CvW_I72-.js";
+import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-groups-DAe1t6zb.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-Bn-nlnSV.js";
 import { i as nodeHttpPrimeBridgeTransport, n as PrimeBridgeTransportRequest, r as PrimeBridgeTransportResult, t as PrimeBridgeTransport } from "../prime-bridge-transport-6feEglLf.js";
 import { z } from "zod";
 //#region src/analyst/adapters.d.ts
@@ -1267,11 +1265,11 @@ 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 = "7747ce4ff600eb66042957aeb46d80c9af0067fe54218e101283ca63f158aec5";
+declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "10c77bd9ce4d896811395f8b623216f51bd03dab9ea209cb58e1d8d7b78acb7a";
 declare const ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 = "1e03f2daed356d60316aabefb407ec1e437ac94d408d61eea4ae096e9c6fbb5b";
 declare const ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 = "4dba263b6256a30d56c7fdb2d992d3a953c0035d731f359b704db806f68f75ac";
 declare const ANALYST_BENCHMARK_IMPLEMENTATION_FILES: readonly string[];
-declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "320fe06f563021515f9b1ed73a4d1fd555266f29b3c32a8cecd2fc13679e6655";
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "ffe86598b87f4fd8e8ba432c5bad5a4a86bba1c4969cfde3b9a28f8c72770d64";
 declare function analystBenchmarkImplementationDigest(): string;
 declare function analystBenchmarkDependencyLockDigest(): string;
 //#endregion