@tangle-network/agent-eval 0.216.1 → 0.217.1

package/dist/types-BqkVmHfv.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-BqkVmHfv.d.ts","names":[],"sources":["../src/supervisor-run/types.ts"],"mappings":"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"}

package/dist/types-C02qtnG8.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-C02qtnG8.d.ts","names":[],"sources":["../src/judge-families.ts","../src/integrity/served-model.ts","../src/trace/raw-provider-sink.ts","../src/llm-client/contract.ts","../src/analyst/chat-client.ts","../src/types.ts"],"mappings":"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"}

package/dist/types-C1tnkEgM.d.ts.map

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

package/dist/types-IXD2HJzu.js.map

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

package/dist/usage-receipt-Cx3xNeyB.js

@@ -1,76 +0,0 @@
-/** Convert one ledger channel's complete call set into one analyst receipt. */
-function usageReceiptFromCostLedger(ledger, filter = "analyst") {
-	const resolvedFilter = typeof filter === "string" ? { channel: filter } : filter;
-	const summary = ledger.summary(resolvedFilter);
-	const receipts = ledger.list(resolvedFilter);
-	const hasReasoningUsage = receipts.some((receipt) => receipt.reasoningTokens !== void 0);
-	const hasCacheWriteUsage = receipts.some((receipt) => receipt.cacheWriteTokens !== void 0);
-	const cost = summary.costProvenance;
-	return {
-		calls: summary.totalCalls + summary.pendingCalls,
-		tokens: summary.usageComplete ? {
-			input: summary.inputTokens,
-			output: summary.outputTokens,
-			...hasReasoningUsage ? { reasoning: summary.reasoningTokens ?? 0 } : {},
-			...summary.cachedTokens > 0 ? { cached: summary.cachedTokens } : {},
-			...hasCacheWriteUsage ? { cacheWrite: summary.cacheWriteTokens ?? 0 } : {}
-		} : null,
-		cost,
-		...cost.kind === "uncaptured" ? { knownCostUsd: summary.totalCostUsd } : {}
-	};
-}
-/** Wait a bounded time for late provider receipts, then take one immutable snapshot. */
-async function settleUsageReceiptFromCostLedger(ledger, options = {}) {
-	const { timeoutMs: requestedTimeoutMs, ...requestedFilter } = options;
-	const filter = {
-		channel: requestedFilter.channel ?? "analyst",
-		...requestedFilter.phase === void 0 ? {} : { phase: requestedFilter.phase },
-		...requestedFilter.tags === void 0 ? {} : { tags: requestedFilter.tags }
-	};
-	const timeoutMs = validateUsageSettlementTimeout(requestedTimeoutMs);
-	const waitResult = ledger.summary(filter).pendingCalls === 0 ? true : ledger.waitForIdle ? await ledger.waitForIdle({ timeoutMs }) : false;
-	const pendingCalls = ledger.summary(filter).pendingCalls;
-	return {
-		settled: waitResult && pendingCalls === 0,
-		pendingCalls,
-		receipt: usageReceiptFromCostLedger(ledger, filter)
-	};
-}
-function validateUsageSettlementTimeout(timeoutMs) {
-	const resolved = timeoutMs ?? 5e3;
-	if (!Number.isSafeInteger(resolved) || resolved < 0 || resolved > 2147483647) throw new TypeError("settlementTimeoutMs must be a non-negative safe integer no greater than 2147483647");
-	return resolved;
-}
-function assertValidAnalystUsageReceipt(receipt, context = "AnalystContext.recordUsage") {
-	if (receipt.calls !== null && (!Number.isSafeInteger(receipt.calls) || receipt.calls < 0)) throw new Error(`${context}: calls must be a non-negative safe integer or null`);
-	if (receipt.tokens) {
-		assertNonNegativeSafeInteger(receipt.tokens.input, "tokens.input", context);
-		assertNonNegativeSafeInteger(receipt.tokens.output, "tokens.output", context);
-		if (receipt.tokens.reasoning !== void 0) {
-			assertNonNegativeSafeInteger(receipt.tokens.reasoning, "tokens.reasoning", context);
-			if (receipt.tokens.reasoning > receipt.tokens.output) throw new Error(`${context}: tokens.reasoning must not exceed tokens.output`);
-		}
-		if (receipt.tokens.cached !== void 0) assertNonNegativeSafeInteger(receipt.tokens.cached, "tokens.cached", context);
-		if (receipt.tokens.cacheWrite !== void 0) assertNonNegativeSafeInteger(receipt.tokens.cacheWrite, "tokens.cacheWrite", context);
-	}
-	if (receipt.cost.kind !== "uncaptured") assertNonNegativeFinite(receipt.cost.usd, "cost.usd", context);
-	else if (receipt.cost.usd !== null) throw new Error(`${context}: uncaptured cost.usd must be null`);
-	if (receipt.knownCostUsd !== void 0) assertNonNegativeFinite(receipt.knownCostUsd, "knownCostUsd", context);
-	if (receipt.partialTokens) {
-		const { input, output } = receipt.partialTokens;
-		if (receipt.tokens) throw new Error(`${context}: partialTokens must be absent when tokens is complete`);
-		if (input === null && output === null) throw new Error(`${context}: partialTokens must carry at least one reported side`);
-		if (input !== null) assertNonNegativeSafeInteger(input, "partialTokens.input", context);
-		if (output !== null) assertNonNegativeSafeInteger(output, "partialTokens.output", context);
-	}
-}
-function assertNonNegativeSafeInteger(value, field, context) {
-	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${context}: ${field} must be a non-negative safe integer`);
-}
-function assertNonNegativeFinite(value, field, context) {
-	if (!Number.isFinite(value) || value < 0) throw new Error(`${context}: ${field} must be a non-negative finite number`);
-}
-//#endregion
-export { validateUsageSettlementTimeout as i, settleUsageReceiptFromCostLedger as n, usageReceiptFromCostLedger as r, assertValidAnalystUsageReceipt as t };
-
-//# sourceMappingURL=usage-receipt-Cx3xNeyB.js.map

package/dist/usage-receipt-Cx3xNeyB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"usage-receipt-Cx3xNeyB.js","names":[],"sources":["../src/analyst/usage-receipt.ts"],"sourcesContent":["import type { CostChannel, CostLedgerFilter, CostLedgerHandle } from '../cost-ledger'\nimport type { AnalystUsageReceipt } from './types'\n\nexport const DEFAULT_USAGE_SETTLEMENT_TIMEOUT_MS = 5_000\n\n/** Convert one ledger channel's complete call set into one analyst receipt. */\nexport function usageReceiptFromCostLedger(\n  ledger: CostLedgerHandle,\n  filter: CostChannel | CostLedgerFilter = 'analyst',\n): AnalystUsageReceipt {\n  const resolvedFilter = typeof filter === 'string' ? { channel: filter } : filter\n  const summary = ledger.summary(resolvedFilter)\n  const receipts = ledger.list(resolvedFilter)\n  const hasReasoningUsage = receipts.some((receipt) => receipt.reasoningTokens !== undefined)\n  const hasCacheWriteUsage = receipts.some((receipt) => receipt.cacheWriteTokens !== undefined)\n  const cost = summary.costProvenance\n  return {\n    calls: summary.totalCalls + summary.pendingCalls,\n    tokens: summary.usageComplete\n      ? {\n          input: summary.inputTokens,\n          output: summary.outputTokens,\n          ...(hasReasoningUsage ? { reasoning: summary.reasoningTokens ?? 0 } : {}),\n          ...(summary.cachedTokens > 0 ? { cached: summary.cachedTokens } : {}),\n          ...(hasCacheWriteUsage ? { cacheWrite: summary.cacheWriteTokens ?? 0 } : {}),\n        }\n      : null,\n    cost,\n    ...(cost.kind === 'uncaptured' ? { knownCostUsd: summary.totalCostUsd } : {}),\n  }\n}\n\nexport interface SettledUsageReceipt {\n  settled: boolean\n  pendingCalls: number\n  receipt: AnalystUsageReceipt\n}\n\n/** Wait a bounded time for late provider receipts, then take one immutable snapshot. */\nexport async function settleUsageReceiptFromCostLedger(\n  ledger: CostLedgerHandle,\n  options: CostLedgerFilter & { timeoutMs?: number } = {},\n): Promise<SettledUsageReceipt> {\n  const { timeoutMs: requestedTimeoutMs, ...requestedFilter } = options\n  const filter: CostLedgerFilter = {\n    channel: requestedFilter.channel ?? 'analyst',\n    ...(requestedFilter.phase === undefined ? {} : { phase: requestedFilter.phase }),\n    ...(requestedFilter.tags === undefined ? {} : { tags: requestedFilter.tags }),\n  }\n  const timeoutMs = validateUsageSettlementTimeout(requestedTimeoutMs)\n  const initial = ledger.summary(filter)\n  const waitResult =\n    initial.pendingCalls === 0\n      ? true\n      : ledger.waitForIdle\n        ? await ledger.waitForIdle({ timeoutMs })\n        : false\n  const pendingCalls = ledger.summary(filter).pendingCalls\n  return {\n    settled: waitResult && pendingCalls === 0,\n    pendingCalls,\n    receipt: usageReceiptFromCostLedger(ledger, filter),\n  }\n}\n\nexport function validateUsageSettlementTimeout(timeoutMs?: number): number {\n  const resolved = timeoutMs ?? DEFAULT_USAGE_SETTLEMENT_TIMEOUT_MS\n  if (!Number.isSafeInteger(resolved) || resolved < 0 || resolved > 2_147_483_647) {\n    throw new TypeError(\n      'settlementTimeoutMs must be a non-negative safe integer no greater than 2147483647',\n    )\n  }\n  return resolved\n}\n\nexport function assertValidAnalystUsageReceipt(\n  receipt: AnalystUsageReceipt,\n  context = 'AnalystContext.recordUsage',\n): void {\n  if (receipt.calls !== null && (!Number.isSafeInteger(receipt.calls) || receipt.calls < 0)) {\n    throw new Error(`${context}: calls must be a non-negative safe integer or null`)\n  }\n  if (receipt.tokens) {\n    assertNonNegativeSafeInteger(receipt.tokens.input, 'tokens.input', context)\n    assertNonNegativeSafeInteger(receipt.tokens.output, 'tokens.output', context)\n    if (receipt.tokens.reasoning !== undefined) {\n      assertNonNegativeSafeInteger(receipt.tokens.reasoning, 'tokens.reasoning', context)\n      if (receipt.tokens.reasoning > receipt.tokens.output) {\n        throw new Error(`${context}: tokens.reasoning must not exceed tokens.output`)\n      }\n    }\n    if (receipt.tokens.cached !== undefined) {\n      assertNonNegativeSafeInteger(receipt.tokens.cached, 'tokens.cached', context)\n    }\n    if (receipt.tokens.cacheWrite !== undefined) {\n      assertNonNegativeSafeInteger(receipt.tokens.cacheWrite, 'tokens.cacheWrite', context)\n    }\n  }\n  if (receipt.cost.kind !== 'uncaptured') {\n    assertNonNegativeFinite(receipt.cost.usd, 'cost.usd', context)\n  } else if (receipt.cost.usd !== null) {\n    throw new Error(`${context}: uncaptured cost.usd must be null`)\n  }\n  if (receipt.knownCostUsd !== undefined) {\n    assertNonNegativeFinite(receipt.knownCostUsd, 'knownCostUsd', context)\n  }\n  if (receipt.partialTokens) {\n    const { input, output } = receipt.partialTokens\n    if (receipt.tokens) {\n      throw new Error(`${context}: partialTokens must be absent when tokens is complete`)\n    }\n    if (input === null && output === null) {\n      throw new Error(`${context}: partialTokens must carry at least one reported side`)\n    }\n    if (input !== null) assertNonNegativeSafeInteger(input, 'partialTokens.input', context)\n    if (output !== null) assertNonNegativeSafeInteger(output, 'partialTokens.output', context)\n  }\n}\n\nfunction assertNonNegativeSafeInteger(value: number, field: string, context: string): void {\n  if (!Number.isSafeInteger(value) || value < 0) {\n    throw new Error(`${context}: ${field} must be a non-negative safe integer`)\n  }\n}\n\nfunction assertNonNegativeFinite(value: number, field: string, context: string): void {\n  if (!Number.isFinite(value) || value < 0) {\n    throw new Error(`${context}: ${field} must be a non-negative finite number`)\n  }\n}\n"],"mappings":"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"}

package/dist/verdict-Dl0tiT1X.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"verdict-Dl0tiT1X.js","names":[],"sources":["../src/verdict.ts"],"sourcesContent":["/**\n * Validator-output verdict — substrate primitive for \"did this output pass,\n * and how well?\"\n *\n * Used by:\n *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.\n *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.\n *     Runtime keeps `Validator` because it's coupled to runtime-shaped\n *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE\n *     itself is a substrate concept and lives here.\n *\n * Repo layering: agent-eval is the substrate (no upward deps). Both\n * agent-runtime and agent-knowledge consume this type FROM agent-eval —\n * never the other way around. See CLAUDE.md \"Repo layering\" for the rule.\n */\n\nimport { contentHash } from './verdict-cache'\nimport type {\n  CheckerIdentity,\n  EquivalenceRecord,\n  VerificationStrategySource,\n} from './verification-strategy'\n\n/**\n * What certified a verdict — the epistemics a bare `valid` + `score` pair\n * cannot carry. A kernel-checked proof and an LLM judge can produce the\n * same `{ valid: true, score: 1 }`; this record is what tells them apart.\n *\n * Every field is required on purpose. A certification without a checker\n * identity or an evidence digest is exactly the unverifiable claim this\n * record exists to kill.\n */\nexport interface VerdictCertification {\n  /**\n   * Which verification-strategy member produced the certificate. Each\n   * member's failure mode is documented on the family type and in\n   * `VERIFICATION_STRATEGIES` (src/verification-strategy.ts).\n   */\n  strategy: VerificationStrategySource\n  /**\n   * Exact checker identity, e.g. `{ name: 'lean4', version: '4.33.0',\n   * pins: { mathlib: 'db584cd6d46c' } }` for a kernel, or a judge model\n   * id + snapshot for a judge.\n   */\n  checker: CheckerIdentity\n  /**\n   * Every step the certificate rests on that the checker did NOT verify,\n   * e.g. 'diagonal embedding argued in prose' or 'agreement arms share\n   * training-corpus blind spots'. An empty array is the producer's\n   * explicit, auditable claim that there are none — it is not a default.\n   */\n  assumptions: string[]\n  /** Digest (e.g. sha256) of the evidence artifact the checker consumed or produced. */\n  evidenceDigest: string\n}\n\n/**\n * Minimal verdict shape — `valid` + `score` are required; `scores` +\n * `notes` are optional surface. Validators that need richer shapes\n * parameterise `Validator<Output, MyVerdict>` with their own type.\n *\n * Need structured extras? Extend DefaultVerdict with typed fields — never\n * serialize extras into `notes`.\n */\nexport interface DefaultVerdict {\n  /** Whether the output meets the validator's pass criteria. */\n  valid: boolean\n  /** Aggregate score in [0, 1]. Drivers use this for winner selection. */\n  score: number\n  /** Per-dimension scores. Free-form; weighted into `score` by the validator. */\n  scores?: Record<string, number>\n  /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */\n  notes?: string\n  /**\n   * What certified this verdict, when anything did. Absent = uncertified:\n   * scored, but no strategy vouches for it. A consumer that cares reads\n   * `certification.strategy` to tell a kernel-checked verdict from a\n   * judge-scored one; a consumer that does not read it sees the exact\n   * verdict it always saw.\n   */\n  certification?: VerdictCertification\n}\n\n/**\n * Digest a certification's evidence artifact: sha-256 over the canonical\n * JSON of the evidence AS SERIALIZED. The JSON round-trip drops\n * `undefined`-valued fields on purpose — certified verdicts persist as\n * JSON, so the digest must cover exactly what a reader of the persisted\n * artifact can re-digest, nothing the wire cannot carry. Throws when the\n * evidence has no JSON form at all.\n */\nexport function certificationEvidenceDigest(evidence: unknown): string {\n  const serialized = JSON.stringify(evidence)\n  if (serialized === undefined) {\n    throw new Error(\n      'certificationEvidenceDigest: evidence has no JSON form — a certificate over nothing is the unverifiable claim this record exists to kill',\n    )\n  }\n  return contentHash(JSON.parse(serialized))\n}\n\n/**\n * Land a finished statement-equivalence record in the shared verdict\n * spine. `valid` answers the protocol's question — are the two blind\n * statements equivalent — so a refutation is `valid: false` even though a\n * separating witness in hand is a successful protocol outcome.\n *\n * Certification is present exactly when the obligation was discharged\n * (proved or refuted): the checker vouches for the discharge either way.\n * An unresolved obligation certifies nothing and keeps its reason in\n * `notes`.\n */\nexport function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict {\n  const { obligation, spec, arms } = record\n  const discharged = obligation.status !== 'unresolved'\n  const notes =\n    obligation.status === 'proved'\n      ? `statements equivalent: ${spec.artifact}`\n      : obligation.status === 'refuted-with-separating-witness'\n        ? `formalization gap witnessed: ${obligation.separatingWitness}`\n        : `obligation undischarged: ${obligation.unresolvedReason}`\n  return {\n    valid: obligation.status === 'proved',\n    score: obligation.status === 'proved' ? 1 : 0,\n    notes,\n    ...(discharged && obligation.evidenceDigest !== undefined\n      ? {\n          certification: {\n            strategy: spec.source,\n            checker: obligation.checker,\n            // The arms' blindness declarations are attested by the arms,\n            // never verified by the checker — the one step every\n            // equivalence certificate rests on.\n            assumptions: [\n              `arm '${arms[0].armId}' and arm '${arms[1].armId}' self-declare blind derivation`,\n            ],\n            evidenceDigest: obligation.evidenceDigest,\n          } satisfies VerdictCertification,\n        }\n      : {}),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,4BAA4B,UAA2B;CACrE,MAAM,aAAa,KAAK,UAAU,QAAQ;CAC1C,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,0IACF;CAEF,OAAO,YAAY,KAAK,MAAM,UAAU,CAAC;AAC3C;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,QAA2C;CAC5E,MAAM,EAAE,YAAY,MAAM,SAAS;CACnC,MAAM,aAAa,WAAW,WAAW;CACzC,MAAM,QACJ,WAAW,WAAW,WAClB,0BAA0B,KAAK,aAC/B,WAAW,WAAW,oCACpB,gCAAgC,WAAW,sBAC3C,4BAA4B,WAAW;CAC/C,OAAO;EACL,OAAO,WAAW,WAAW;EAC7B,OAAO,WAAW,WAAW,WAAW,IAAI;EAC5C;EACA,GAAI,cAAc,WAAW,mBAAmB,KAAA,IAC5C,EACE,eAAe;GACb,UAAU,KAAK;GACf,SAAS,WAAW;GAIpB,aAAa,CACX,QAAQ,KAAK,EAAE,CAAC,MAAM,aAAa,KAAK,EAAE,CAAC,MAAM,gCACnD;GACA,gBAAgB,WAAW;EAC7B,EACF,IACA,CAAC;CACP;AACF"}

package/dist/verdict-cache-Bm8EKL2s.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"verdict-cache-Bm8EKL2s.js","names":[],"sources":["../src/verdict-cache.ts"],"sourcesContent":["/**\n * Content-addressed judge-verdict caching.\n *\n * LAW: cache JUDGE VERDICTS only — judging the same artifact with the same\n * judge+rubric is pure. NEVER cache agent rollouts. (A router that cached\n * identical fanout prompts silently destroyed best-of-N diversity; rollout\n * caching reintroduces that failure class. Judging has no diversity to\n * destroy — same artifact + same rubric ⇒ same verdict is the desired\n * property, not a bug.)\n *\n * The cache key is `v2:` + a sha-256 over the canonical JSON of everything\n * that can change a verdict: the artifact content, the scenario id, the judge\n * name, the full dimension list (key + description — the description IS the\n * rubric text shown to the judge), and a caller-supplied `judgeVersion`.\n * `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes\n * without a version bump would otherwise silently serve stale verdicts.\n * The `v2:` prefix names the key scheme; a store written under another scheme\n * misses once and repopulates.\n *\n * Canonical JSON is RFC 8785 from `ledger-core/canonical` — the package's one\n * identity scheme. It refuses `undefined`, functions, symbols, non-finite\n * numbers, class instances (including `Date`), `Map`, `Set`, cycles, and\n * unpaired surrogates: an artifact that cannot be unambiguously serialized\n * cannot be content-addressed, and coercing it would let two different\n * artifacts collide on one key. Pass timestamps as ISO strings.\n */\n\nimport { appendFileSync, existsSync, readFileSync } from 'node:fs'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\nimport { canonicalString, hashCanonical } from './ledger-core/canonical'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\n/** Key scheme of every entry `cachedJudge` writes. */\nexport const VERDICT_CACHE_KEY_SCHEME = 'v2'\n\n/**\n * Canonical JSON (RFC 8785): object keys sorted recursively, so two\n * semantically equal values produce byte-identical output regardless of key\n * insertion order. Throws `LedgerCanonicalizationError` on any value with no\n * faithful JSON form — see `ledger-core/canonical`.\n */\nexport function canonicalJson(value: unknown): string {\n  return canonicalString(value)\n}\n\n/** Hex sha-256 over `canonicalJson(value)`. The content address used by the\n *  verdict cache and report attestation. Equals `hashCanonical(value)` with\n *  the `sha256:` prefix removed. */\nexport function contentHash(value: unknown): string {\n  return hashCanonical(value).slice('sha256:'.length)\n}\n\n// ── store contract ─────────────────────────────────────────────────────────\n\n/** Pluggable verdict store. Sync or async on both legs — `cachedJudge`\n *  awaits the results either way. */\nexport interface VerdictCacheStore {\n  get(key: string): Promise<JudgeScore | undefined> | JudgeScore | undefined\n  set(key: string, score: JudgeScore): Promise<void> | void\n}\n\n/** Process-local Map-backed store. */\nexport function inMemoryVerdictCache(): VerdictCacheStore {\n  const entries = new Map<string, JudgeScore>()\n  return {\n    get: (key) => entries.get(key),\n    set: (key, score) => {\n      entries.set(key, score)\n    },\n  }\n}\n\ninterface VerdictCacheLine {\n  key: string\n  score: JudgeScore\n}\n\nfunction parseCacheLine(line: string, path: string, lineNo: number): VerdictCacheLine {\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(line)\n  } catch (err) {\n    throw new Error(\n      `fileVerdictCache: corrupt JSONL at ${path}:${lineNo} — ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n  const rec = parsed as Partial<VerdictCacheLine>\n  if (\n    typeof rec !== 'object' ||\n    rec === null ||\n    typeof rec.key !== 'string' ||\n    typeof rec.score !== 'object' ||\n    rec.score === null ||\n    typeof rec.score.composite !== 'number' ||\n    typeof rec.score.dimensions !== 'object'\n  ) {\n    throw new Error(\n      `fileVerdictCache: invalid record shape at ${path}:${lineNo} — expected {key, score:{dimensions, composite, notes}}`,\n    )\n  }\n  return rec as VerdictCacheLine\n}\n\n/**\n * JSONL-file-backed store: the full file is loaded into an in-memory index at\n * construction; every `set` appends one line synchronously (durable before\n * the verdict is returned). A corrupt or malformed line throws at load with\n * file:line — a skipped line would silently re-judge (cost) or, worse, mask\n * a half-written file that needs operator attention.\n */\nexport function fileVerdictCache(path: string): VerdictCacheStore {\n  const entries = new Map<string, JudgeScore>()\n  if (existsSync(path)) {\n    const lines = readFileSync(path, 'utf8').split('\\n')\n    for (let i = 0; i < lines.length; i++) {\n      const line = lines[i]\n      if (line === undefined || line.trim() === '') continue\n      const rec = parseCacheLine(line, path, i + 1)\n      entries.set(rec.key, rec.score)\n    }\n  }\n  return {\n    get: (key) => entries.get(key),\n    set: (key, score) => {\n      appendFileSync(path, `${JSON.stringify({ key, score })}\\n`, 'utf8')\n      entries.set(key, score)\n    },\n  }\n}\n\n// ── cached judge wrapper ───────────────────────────────────────────────────\n\nexport interface VerdictCacheStats {\n  hits: number\n  misses: number\n}\n\nexport interface CachedJudgeOptions {\n  /** REQUIRED — part of the cache key. Bump on any change to the judge's\n   *  prompt, model, ensemble, or scoring logic; silent judge upgrades must\n   *  never serve stale verdicts. */\n  judgeVersion: string\n}\n\n/** The wrapped judge: same `JudgeConfig` seam, plus hit/miss observability. */\nexport type CachedJudge<TArtifact, TScenario extends Scenario = Scenario> = JudgeConfig<\n  TArtifact,\n  TScenario\n> & {\n  stats(): VerdictCacheStats\n}\n\n/**\n * Wrap a `JudgeConfig` so repeat judgments of the same artifact are served\n * from the store instead of re-invoking `score()`. The wrapper is generic\n * over the judge's own type parameters and preserves `appliesTo` — it is a\n * drop-in replacement anywhere a `JudgeConfig` is accepted.\n *\n * A judge that throws is NOT cached: the error propagates and the next\n * attempt re-judges (caching a failure would pin a transient outage forever).\n */\nexport function cachedJudge<TArtifact, TScenario extends Scenario = Scenario>(\n  judge: JudgeConfig<TArtifact, TScenario>,\n  store: VerdictCacheStore,\n  options: CachedJudgeOptions,\n): CachedJudge<TArtifact, TScenario> {\n  if (typeof options.judgeVersion !== 'string' || options.judgeVersion.trim() === '') {\n    throw new Error('cachedJudge: judgeVersion is required and must be a non-empty string')\n  }\n  const stats: VerdictCacheStats = { hits: 0, misses: 0 }\n  const wrapped: CachedJudge<TArtifact, TScenario> = {\n    name: judge.name,\n    dimensions: judge.dimensions,\n    judgeVersion: options.judgeVersion,\n    async score(input) {\n      const key = `${VERDICT_CACHE_KEY_SCHEME}:${contentHash({\n        artifact: canonicalJson(input.artifact),\n        scenarioId: input.scenario.id,\n        judgeName: judge.name,\n        dimensions: judge.dimensions,\n        judgeVersion: options.judgeVersion,\n      })}`\n      const cached = await store.get(key)\n      if (cached !== undefined) {\n        stats.hits += 1\n        return cached\n      }\n      const score = await judge.score(input)\n      await store.set(key, score)\n      stats.misses += 1\n      return score\n    },\n    stats: () => ({ ...stats }),\n  }\n  if (judge.appliesTo) wrapped.appliesTo = judge.appliesTo\n  return wrapped\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,cAAc,OAAwB;CACpD,OAAO,gBAAgB,KAAK;AAC9B;;;;AAKA,SAAgB,YAAY,OAAwB;CAClD,OAAO,cAAc,KAAK,CAAC,CAAC,MAAM,CAAgB;AACpD;AA2BA,SAAS,eAAe,MAAc,MAAc,QAAkC;CACpF,IAAI;CACJ,IAAI;EACF,SAAS,KAAK,MAAM,IAAI;CAC1B,SAAS,KAAK;EACZ,MAAM,IAAI,MACR,sCAAsC,KAAK,GAAG,OAAO,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,GAC3G;CACF;CACA,MAAM,MAAM;CACZ,IACE,OAAO,QAAQ,YACf,QAAQ,QACR,OAAO,IAAI,QAAQ,YACnB,OAAO,IAAI,UAAU,YACrB,IAAI,UAAU,QACd,OAAO,IAAI,MAAM,cAAc,YAC/B,OAAO,IAAI,MAAM,eAAe,UAEhC,MAAM,IAAI,MACR,6CAA6C,KAAK,GAAG,OAAO,wDAC9D;CAEF,OAAO;AACT;;;;;;;;AASA,SAAgB,iBAAiB,MAAiC;CAChE,MAAM,0BAAU,IAAI,IAAwB;CAC5C,IAAI,WAAW,IAAI,GAAG;EACpB,MAAM,QAAQ,aAAa,MAAM,MAAM,CAAC,CAAC,MAAM,IAAI;EACnD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,SAAS,KAAA,KAAa,KAAK,KAAK,MAAM,IAAI;GAC9C,MAAM,MAAM,eAAe,MAAM,MAAM,IAAI,CAAC;GAC5C,QAAQ,IAAI,IAAI,KAAK,IAAI,KAAK;EAChC;CACF;CACA,OAAO;EACL,MAAM,QAAQ,QAAQ,IAAI,GAAG;EAC7B,MAAM,KAAK,UAAU;GACnB,eAAe,MAAM,GAAG,KAAK,UAAU;IAAE;IAAK;GAAM,CAAC,EAAE,KAAK,MAAM;GAClE,QAAQ,IAAI,KAAK,KAAK;EACxB;CACF;AACF"}

package/docs/design/self-improvement-evidence-audit.md

@@ -1,263 +0,0 @@
-# Evidence audit: selfImprove and optimizer benefit
-
-Historical runs contain gains, nulls, and regressions.
-They do not establish optimizer superiority over a direct edit or current-branch improvement across tasks.
-A historical GEPA analyst comparison reported 0.4285 to 0.4809 pooled micro F1, with important validity limits described below.
-A later GEPA challenger lost 0.0561 on fresh agent families.
-These results justify preserving candidates, checking transfer, and reporting negative or inconclusive outcomes.
-
-This was a read-only audit on 2026-09-13 of `feat/evaluation-integrity` over `dda9941437190c9c541b3f54946bfeeb153366fe`.
-The implementation changes were uncommitted during inspection.
-No paid calls or new model experiments ran for this audit.
-Current-branch fixture tests are distinct from all historical model results below.
-
-## Inspected evidence
-
-Paths below are relative to the repository root unless stated otherwise.
-
-- All 10 [registry records](../../evidence/INDEX.md): 2 `CERTIFIED`, 6 `MEASURED-ONCE`, 1 `RESOLVED-NULL`, and 1 `UNVERIFIED`.
-  These are registry labels; this audit did not recertify those records.
-- The archived extraction comparison, its original implementation, and 20 optimization-related notebook records.
-- Four committed CodeTraceBench result files, both certification reports, and both preregistrations.
-- Current selfImprove, final-comparison, method-integrity, and final-evidence fixtures.
-
-Searches covered `evidence/`, `examples/`, `benchmarks/`, `docs/`, and `.evolve/`.
-There was no root `results/` directory and only one archived method-comparison JSON in examples.
-Queries used `rg`, `git show` at the producing revision, and Python JSON parsing.
-For each committed analyst result, model observation counts, positive-label micro F1, call totals, and cost sums were independently recomputed.
-
-The following referenced raw artifacts were unavailable locally:
-
-- `~/bench-cache/ctb-20260801/certification/`: incumbent and manual-width-adaptive arms.
-- `~/bench-cache/ctb-20260801/cert2/`: rejected G2 arms.
-- `.evolve/substrate-proof/appworld/d3-scaled-comparison.json`.
-- `.evolve/compare-optimization-methods/` and `.evolve/compare-drivers/`.
-- `examples/findings-ablation/index.ts` and the referenced session scratch artifacts for bridge and CAD proofs.
-
-The registry's `.evolve/certification-2026-08-02-preregistration.md` reference is stale.
-The committed replacement is [benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/preregistration.md](../../benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/preregistration.md).
-
-## Model-backed evidence
-
-| Date and task | Optimizer and comparison | Observed result | Units and costs | Evidence limit |
-| --- | --- | --- | --- | --- |
-| June 1, transaction extraction | Package-local GEPA-style reflection, GEPA-style Pareto, and SkillOpt-style patching versus an intentionally underspecified prompt | Baseline 0.625; reflection and SkillOpt 1.0; Pareto 0.958 | 8 search cases, 6 reported final cases; 182 captured worker calls; $0.013237 captured worker cost | SkillOpt selected on the reported final set; optimizer model costs omitted; no official Python optimizers |
-| June 1, findings ablation | Local GEPA with versus without analyst findings | Both 1.0 from baseline 0.625; difference 0, archived CI [0, 0] | 6 reported cases, 130 calls, $0.009, 131 seconds | Zero findings were generated; the proposed mechanism never activated; notebook only |
-| May 30, legal agents | Local gepaDriver candidates versus incumbent | Candidate fee scores 100 to 83/92; hallucination-free score 100 to 85; selected baseline | 4 scorable personas; 2 named final personas; gen1/pop2/reps2 | Model, cost, and complete paired rows missing; notebook only |
-| June 1, AppWorld difficulty 3 | Local drivers versus a competent baseline, deepseek-v4-pro worker | Small baseline 0.794, lift 0; scaled baseline 0.885, both GEPA lifts 0; memory -0.047 | Small n=6; scaled notebook n=8 with unclear repeated-cell meaning; scaled cost $2.58 | Raw comparison absent; null does not isolate whether remaining errors are prompt-fixable |
-| August 1, CodeTraceBench analyst | Real Python GEPA instructions versus stock and manual width-adaptive arm, glm-5.2 | Pooled micro F1: GEPA 0.4809, stock 0.4285, manual 0.4047 | 69 cases, 2 reps, 138 model observations per arm; search $4.46; six comparison runs documented $50.63 | Paired intervals cross zero; point-estimate promotion; split3 later retired; baseline raw files unavailable |
-| August 2, CodeTraceBench transfer | Real Python GEPA G2 versus shipping G1, same analyst engine/model | Fresh pooled micro F1 0.1928 versus 0.2489; G2 rejected | 64 cases, 128 observations per arm; search $7.05; four comparison runs documented $31.07 | G2 raw files unavailable; intervals cross zero; Terminus2 has 30 source clusters for 32 cases |
-| August 3, cross-family selection | Real GEPA prompt search with a macro objective | Macro 0.163 to 0.187; micro 0.3399 to 0.1897; TP 26 to 11; recall 0.325 to 0.138 | 24 train / 16 selection cases, 56 evaluations, $6.42 | Selection-only rejection; no fresh final experiment; notebook only |
-| August 19–20, AIME | Official Python GEPA and live bridge; glm-5.3 worker, deepseek-v4-flash optimizer | Search completed in attempts 11–14; final comparison never completed | Train8/selection8/final10; 14 launches; about $4 reported | Machinery evidence, no lift verdict; substantial shared-host contention and task timeouts |
-| August 20, CLI bridge toy | Official GEPA autoresearch engine and unmodified Claude CLI through a loopback route | Deterministic length objective about 0.286 to 1.0 | 12 optimizer evaluations, 2 submitted candidates, 8/8 wire calls, $0.029778336, 39.7 seconds | Real candidate-authoring calls; deterministic toy score; registry-only artifacts |
-| June 8, OpenSCAD directive | GEPA versus handwritten directive | Reported +9.5 percentage points on compiled-CAD quality | One final split; task count and cost missing | Weak external-repository pointer; no pinned command or run directory |
-
-The AppWorld notebook also reports GSM8K baseline 1.0 with both deepseek-v4-pro and deepseek-v4-flash.
-Its sample counts and costs are absent.
-Its aggregate phrase “five configs” does not reconcile with its enumerated task variants; no total run count is inferred here.
-The findings and extraction records are related demonstrations and must not be counted as independent replication.
-
-### June extraction: exact limitations
-
-Artifact: [examples/compare-optimization-methods/results/deepseek-chat-20260601.json](../../examples/compare-optimization-methods/results/deepseek-chat-20260601.json).
-It was created at `a648fae334c740d8e0f368e81f68ae933cdb1135` under `examples/compare-drivers-canonical/results/`.
-The current directory name does not identify the historical optimizer implementation.
-
-At that revision, inspect these producing sources with `git show`:
-
-- `examples/compare-drivers-canonical/index.ts`.
-- `examples/_shared/extraction-task.ts`.
-- `src/campaign/presets/compare-drivers.ts`.
-- `src/campaign/presets/run-skill-opt.ts`.
-- `src/campaign/presets/run-improvement-loop.ts`.
-- `src/campaign/drivers/gepa.ts` and `src/campaign/drivers/skill-opt.ts`.
-
-The baseline was `Extract the transaction info from the message as JSON.`
-The optimizer received the omitted schema, formatting rules, and suggested mutation primitives.
-Winners mainly supplied merchant, amount, date, category, and formatting requirements.
-The deterministic composite averages four normalized field matches; six transactions are the sample units, not 24 independent fields.
-No direct edit control tested whether copying the supplied requirements achieved the same benefit.
-
-The same `HOLDOUT` entered the inner optimizers and the outer comparison.
-SkillOpt accepted patches using those six cases and fed rejection scores plus accepted-delta notes into subsequent proposals.
-Its reported final score is therefore selection-set performance.
-The GEPA-style entries selected on train, then exposed those cases to an inner gate before outer rescoring.
-Their returned surface did not depend on that gate.
-This establishes unequal final-data access; it does not prove that every numerical GEPA gain was false.
-
-| Historical driver | Baseline | Candidate | Lift | Archived lift CI | Captured driver scoring cost |
-| --- | ---: | ---: | ---: | --- | ---: |
-| gepa-reflection | 0.625 | 1.000 | 0.375 | [0.167, 0.542] | $0.002921 |
-| skill-opt | 0.625 | 1.000 | 0.375 | [0.167, 0.542] | $0.004005 |
-| gepa-pareto | 0.625 | 0.958 | 0.333 | [0.167, 0.542] | $0.002929 |
-
-Reflection versus SkillOpt had delta 0, CI [0, 0].
-Reflection versus Pareto had delta 0.042, CI [0, 0.125].
-Both archived comparisons used `favored: 'tie'`; that does not establish equivalence.
-
-Captured worker usage was 18,226 input tokens and 7,560 output tokens across 182 records over 126 seconds.
-The rate calculation `18226 * 0.27 / 1e6 + 7560 * 1.10 / 1e6 = 0.01323702` matches the rounded artifact cost.
-The listed driver costs sum to $0.009855; $0.003382 of captured worker cost has no named phase breakdown in this artifact.
-More importantly, the captured `records` array was populated only by the extraction worker.
-The optimizer drivers called `callLlm` directly and discarded model usage and cost.
-Therefore, end-to-end optimization cost and total model-call count are unknown.
-The archived `honestVerdict: 'lift-proven'` is not valid current certification or proof of optimizer superiority.
-
-### CodeTraceBench: useful gains and failed transfer
-
-Full source reports and all measured fields:
-
-- [benchmarks/trace-analysis/codetracebench-glm52-certified-20260801/README.md](../../benchmarks/trace-analysis/codetracebench-glm52-certified-20260801/README.md) and `preregistration.md`.
-- [benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/README.md](../../benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/README.md) and `preregistration.md`.
-- `.evolve/experiments.jsonl`, lines 26, 29, 33, 34, and 41.
-
-Round 1 used real Python GEPA at historical script revision `0eb2e32`, with 40 evaluations on 10 train and 6 selection cases.
-The output contract stayed fixed.
-The selected prompt hash was `d3829fb855690a3a385f498049801c14bb990c6e49858a6739bd331c0ab324e1`.
-Search selection composite rose from 0.281 to 0.331; this is separate from final micro F1.
-
-The final experiment used glm-5.2 through z.ai, stock DSPy RLM execution, seed0, and two repetitions.
-Arms ran serially; each run used concurrency6, maxOutput8192, timeout1,200,000ms, maxCost30, and maxArtifact8MiB.
-The environment was Node24.16.0 on Linux x64.
-The dataset revision was `aa213b84ffb6690fc37ca15766d6ca174ec36d4d`.
-Model names were recorded; a provider-served immutable model snapshot was not demonstrated by this audit.
-
-| Arm and final split | Micro F1 | Macro F1 | Recall | Precision | Failed model observations | Documented cost |
-| --- | ---: | ---: | ---: | ---: | --- | ---: |
-| Incumbent / holdout2 | 0.5641 | 0.5596 | 0.6436 | 0.5021 | 0/64 | $7.97 |
-| Manual W / holdout2 | 0.5224 | 0.5125 | 0.5426 | 0.5037 | 1/64 | $7.67 |
-| GEPA G / holdout2 | 0.6288 | 0.5789 | 0.6622 | 0.5986 | 0/64 | $7.96 |
-| Incumbent / split3 | 0.1693 | 0.1830 | 0.3276 | 0.1141 | 1/74 | $9.24 |
-| Manual W / split3 | 0.1805 | 0.1791 | 0.3190 | 0.1259 | 1/74 | $8.72 |
-| GEPA G / split3 | 0.1799 | 0.1844 | 0.3017 | 0.1282 | 0/74 | $9.07 |
-
-There were 32 holdout2 cases and 37 split3 cases: 69 cases and 138 model observations per arm.
-Only 30 holdout2 cases had positive labels; the paired F1 table consequently used 30 + 37 = 67 positive cases.
-The notebook's “67 fresh cases” must not replace the execution denominator.
-Pooled macro F1 was G0.3611, incumbent0.3516, and W0.3284.
-
-G versus incumbent paired F1 intervals were [-0.027, +0.067] on holdout2 and [-0.042, +0.046] on split3.
-W intervals were [-0.096, +0.001] and [-0.064, +0.053], respectively.
-Reported median paired delta was zero for all four comparisons.
-Promotion followed a preregistered pooled point-estimate rule; it did not require statistical exclusion of zero.
-The wide-cascade holdout2 gain of 0.0647 is a useful historical signal.
-
-After certification, split3 was retired: 27/37 cases label the final submit step.
-A constant last-step prediction scored micro F1 0.568 there, versus about 0.180 for the analyst.
-Consequently, the pooled result cannot support a general analysis-quality claim.
-The reports' stronger language about unbiased instruments and certification must be read with this disclosed correction.
-
-G2 search later improved a weighted selection objective by 0.064 on 12 cases, with micro F1 0.400 to 0.509 and macro -0.032.
-On fresh OpenHands and Terminus2, G2 pooled micro was 0.1928 versus stock0.2489, with 3/128 versus 0/128 failures.
-Per-family G2 micro was OH0.2086/T20.1822, versus stock OH0.2896/T20.2162.
-Paired intervals were OH[-0.126, +0.058] and T2[-0.143, +0.023].
-The fixed promotion rule rejected G2; its selection gain did not transfer.
-The later August3 macro-versus-micro divergence was found on selection data and is not another fresh final result.
-
-### Raw recomputation and accounting
-
-These four files contain the surviving model arm and an empty control; they do not contain the unavailable incumbent/W/G2 arms.
-Historical comparison deltas and intervals therefore remain documented evidence rather than independently reconstructed comparisons.
-
-| Label | Committed raw result | Run identity SHA256 |
-| --- | --- | --- |
-| G/h2 | [benchmarks/trace-analysis/codetracebench-glm52-certified-20260801/result-holdout2.json](../../benchmarks/trace-analysis/codetracebench-glm52-certified-20260801/result-holdout2.json) | `24883695f29e0b928f3a55d000e985682d18f810eb63c2c70b00e95418a34fac` |
-| G/s3 | [benchmarks/trace-analysis/codetracebench-glm52-certified-20260801/result-split3.json](../../benchmarks/trace-analysis/codetracebench-glm52-certified-20260801/result-split3.json) | `417161b661138fb03977e475ae76be22e54d2153b32bb1842c0a6dde49ecc200` |
-| Stock/OH | [benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/result-stock-openhands.json](../../benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/result-stock-openhands.json) | `30d80958be3d71f56a780850c7791cb4d078a8d98bc696140181611f94f7be95` |
-| Stock/T2 | [benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/result-stock-terminus2.json](../../benchmarks/trace-analysis/codetracebench-crossfamily-cert-20260802/result-stock-terminus2.json) | `abda3035ded04b3625981b2073d6b24a152fb4223836471481d4858f8a9589a3` |
-
-| Label | Observations / cases / clusters | Positive / negative / unlabeled observations | Positive-label TP / FP / FN | Recomputed micro F1 | Model calls | Estimated model cost |
-| --- | --- | --- | --- | ---: | ---: | ---: |
-| G/h2 | 64 / 32 / 32 | 60 / 0 / 4 | 249 / 167 / 127 | 0.628787879 | 912 | $7.9586602 |
-| G/s3 | 74 / 37 / 37 | 74 / 0 / 0 | 35 / 238 / 81 | 0.179948586 | 1045 | $9.0744110 |
-| Stock/OH | 64 / 32 / 32 | 32 / 28 / 4 | 43 / 80 / 131 | 0.289562290 | 855 | $7.3335628 |
-| Stock/T2 | 64 / 32 / 30 | 32 / 20 / 12 | 40 / 130 / 160 | 0.216216216 | 883 | $7.5553616 |
-
-Counts, call totals, and estimated cost sums reconcile against each result summary.
-All four model arms have zero failed observations, zero unknown-cost observations, and zero unknown token-usage observations.
-Every model observation explicitly labels its cost `estimated`; the reports' wording “measured cost” must not imply provider-billed receipts.
-The table does not include GEPA search cost or missing comparison arms.
-
-| Label | Input tokens | Output tokens | Cached tokens | Reasoning tokens | Unknown cache-write usage observations |
-| --- | ---: | ---: | ---: | ---: | ---: |
-| G/h2 | 2,055,464 | 578,167 | 9,089,024 | 0 | 64/64 |
-| G/s3 | 2,553,890 | 659,891 | 10,150,528 | 0 | 74/74 |
-| Stock/OH | 2,336,470 | 445,036 | 8,254,336 | 0 | 64/64 |
-| Stock/T2 | 2,257,624 | 457,760 | 8,656,192 | 0 | 64/64 |
-
-Cache-write usage is unknown for every observation; summary zero totals do not establish measured zeros.
-Trusted-negative false-positive rates are OH0.5 on 28 observations and T20.6 on 20 observations.
-They are null on h2/s3 because those model arms have no trusted-negative observations.
-The normalized calibration F1 includes negative predictions, giving OH0.243626062 and T20.189573460.
-Those are different quantities from the historical positive-label micro F1 above.
-
-| Label | Latency minimum ms | Median ms | Mean ms | p95 ms | Maximum ms |
-| --- | ---: | ---: | ---: | ---: | ---: |
-| G/h2 | 58,387.888 | 134,080.197 | 149,395.929 | 280,446.514 | 388,678.939 |
-| G/s3 | 66,049.095 | 131,120.154 | 150,738.482 | 281,274.392 | 348,210.556 |
-| Stock/OH | 50,270.252 | 101,125.396 | 112,446.304 | 203,914.120 | 233,030.922 |
-| Stock/T2 | 40,764.354 | 108,713.527 | 118,436.742 | 206,919.628 | 223,641.819 |
-
-Latency is per completed analyst observation under concurrency6; it is not serial campaign duration.
-The exact protocol, implementation, dependency-lock, labels, trace, and candidate hashes remain in the linked raw results.
-
-## Current selected-candidate behavior
-
-The implementation preserves the search-selected candidate independently of its final gate decision.
-`runFinalComparison()` compares that selected surface without selecting a replacement.
-`src/contract/self-improve-method.ts` returns `selected.winnerSurface`.
-`src/contract/self-improve.ts` returns `result.winnerSurface`.
-
-Inspected fixtures establish these intended behaviors:
-
-- `tests/campaign/final-evidence-integration.test.ts`: eight independent binary pairs produce lift1 and default-gate `ship`.
-  The declared-unit comparison runs twice without consuming evidence when no ledger policy is supplied.
-- The same file: four fractional pairs preserve `WIN` and lift0.215 while the default gate returns `hold`.
-- `tests/contract-self-improve-method-integrity.test.ts`: method-selected `WIN` remains selected despite losing on train.
-  Four final dispatches produce lift0.4; this test injects an always-ship gate.
-- Deferred-final fixtures preserve the selected candidate, execute zero final calls, and leave final score/lift absent.
-- No-op fixtures return the baseline and hold; these reflect unchanged selection rather than gate-driven candidate replacement.
-- Ledger lifecycle fixtures cover method and proposer paths with an injected hold gate.
-
-These are fixed, marker, or echo fixtures.
-Some controlled receipt fixtures set backend `real`; that literal does not turn them into model-backed efficacy evidence.
-This historical audit inspected fixture source independently of the implementation's test runs.
-The implementation also adds a default-gate regression for a selected candidate that loses on final tasks.
-It checks negative lift, a refusing gate, and preservation of the selected candidate.
-
-The branch's `claim` option declares units separately from optional fresh-evidence accounting.
-This separation supports repeated development comparisons without misrepresenting them as new confirmation.
-The interval API also seals the cluster-bootstrap `value` selector in `IntervalSpec`; submitted row evidence no longer chooses it after sealing.
-Neither API correction is itself evidence of improved model behavior.
-
-## Smallest meaningful benefit experiment
-
-Use the current public `selfImprove({ method, claim })` path with the maintained official optimizer and the production agent entrypoint.
-Choose a real task panel with observed prompt-fixable errors under a reasonable current baseline.
-Do not manufacture benefit solely by withholding known output requirements from that baseline.
-
-1. Run a small execution-and-capture smoke before a full search.
-   Verify candidate identity, worker and optimizer receipts, missingness, and retained raw scores.
-2. Use three arms: unchanged baseline, a direct edit from the same development evidence, and the official optimizer.
-   Fix authoring/search resource limits and preserve actual spending separately for each arm.
-3. Partition by source task or incident into development, selection, and fresh final units.
-   Pin the population, practical effect, primary metric, failure policy, and stopping rule before final exposure.
-4. Estimate final sample size from development variation and the desired practical effect using maintained power helpers.
-   Count independent source units and account for clustering; do not substitute repeated calls or a universal 20-unit floor.
-5. Freeze the selected candidates and compare all arms on paired final units under a balanced execution schedule.
-   Report baseline-to-candidate lift and optimizer-to-direct-edit lift, including uncertainty, failures, costs, and latency.
-6. Use the final-evidence ledger when making a fresh-confirmation claim.
-   Retain the candidate, its diff, and all observed scores even when the gate holds or evidence is inconclusive.
-
-No paid experiment was launched by this audit.
-A cost forecast should use the current configured model rates and observed smoke usage before the search starts.
-A single successful search demonstrates that run's benefit; repeat searches are required to estimate optimizer reliability across seeds or tasks.
-
-## Supported communication
-
-The implementation improves how users declare claims, preserve evidence, inspect uncertainty, and compare selected candidates.
-Historical useful-task optimization has produced gains, nulls, and regressions.
-The evidence supports testing automated evaluation engineering through explicit outcome checks and independent confirmation.
-It does not support claiming universal self-improvement, optimizer superiority over a direct edit, or current-branch model-quality lift.
-
-See [evaluation integrity](../evaluation-integrity.md) for the public API and the book chapters motivating its methodology.