@tangle-network/agent-eval 0.138.0 → 0.139.0

package/dist/canonical-D011XM8r.js

@@ -0,0 +1,86 @@
+import { c as ValidationError } from "./errors-D-LKuDhb.js";
+import { canonicalCandidateBytes, canonicalCandidateJson, sha256Bytes } from "@tangle-network/agent-interface";
+//#region src/ledger-core/canonical.ts
+/**
+* Canonical bytes and digests for durable journal rows.
+*
+* Serialization is RFC 8785 through `@tangle-network/agent-interface` — the
+* stack's single identity scheme — so a value carries the same digest in every
+* package that produces or verifies one.
+*
+* Values canonical JSON cannot represent faithfully are refused, never coerced.
+* `NaN`, `Infinity`, `undefined`, class instances, cycles, and unpaired
+* surrogates each have a lossy encoding that maps distinct records onto one
+* digest, and in a hash chain the digest IS the record's identity: a coercion
+* there is a collision, not a convenience.
+*/
+/** Shape of every ledger digest: `sha256:` followed by 64 lowercase hex chars. */
+const LEDGER_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+/** A value has no faithful canonical-JSON form, so it cannot be stored or hashed. */
+var LedgerCanonicalizationError = class extends ValidationError {};
+/** Canonical JSON encoding (RFC 8785): object keys sorted by UTF-16 code unit,
+* recursively. This is the byte form that is hashed and stored, so equal values
+* always encode identically. */
+function canonicalString(value) {
+	try {
+		return canonicalCandidateJson(value);
+	} catch (error) {
+		throw canonicalizationError(value, error);
+	}
+}
+function hashCanonical(value) {
+	try {
+		return sha256Bytes(canonicalCandidateBytes(value));
+	} catch (error) {
+		throw canonicalizationError(value, error);
+	}
+}
+/** Name the offending value and path so a refusal is actionable. The RFC 8785
+* encoder above is the sole authority on acceptance; this walk only explains a
+* rejection it already made. */
+function canonicalizationError(value, cause) {
+	const defect = firstNonCanonicalDefect(value, "$", /* @__PURE__ */ new Set());
+	return new LedgerCanonicalizationError(`value has no canonical JSON form: ${defect !== "" ? defect : cause instanceof Error ? cause.message : String(cause)}`, { cause });
+}
+function firstNonCanonicalDefect(value, path, ancestors) {
+	if (value === null) return "";
+	if (value === void 0) return `${path} is undefined`;
+	const type = typeof value;
+	if (type === "number") return Number.isFinite(value) ? "" : `${path} is ${String(value)}`;
+	if (type === "string") return isWellFormedUtf16(value) ? "" : `${path} contains an unpaired surrogate`;
+	if (type === "boolean") return "";
+	if (type !== "object") return `${path} is a ${type}`;
+	const object = value;
+	if (ancestors.has(object)) return `${path} closes a reference cycle`;
+	const prototype = Object.getPrototypeOf(object);
+	if (!Array.isArray(object) && prototype !== Object.prototype && prototype !== null) return `${path} is a ${object.constructor?.name ?? "non-plain"} instance, not plain JSON data`;
+	const nested = new Set(ancestors).add(object);
+	if (Array.isArray(object)) {
+		for (let index = 0; index < object.length; index += 1) {
+			const defect = firstNonCanonicalDefect(object[index], `${path}[${index}]`, nested);
+			if (defect !== "") return defect;
+		}
+		return "";
+	}
+	for (const [key, entry] of Object.entries(object)) {
+		if (!isWellFormedUtf16(key)) return `${path}.${key} has a key with an unpaired surrogate`;
+		const defect = firstNonCanonicalDefect(entry, `${path}.${key}`, nested);
+		if (defect !== "") return defect;
+	}
+	return "";
+}
+function isWellFormedUtf16(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code >= 55296 && code <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (!(next >= 56320 && next <= 57343)) return false;
+			index += 1;
+		} else if (code >= 56320 && code <= 57343) return false;
+	}
+	return true;
+}
+//#endregion
+export { hashCanonical as i, LedgerCanonicalizationError as n, canonicalString as r, LEDGER_HASH_PATTERN as t };
+
+//# sourceMappingURL=canonical-D011XM8r.js.map

package/dist/canonical-D011XM8r.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-D011XM8r.js","names":[],"sources":["../src/ledger-core/canonical.ts"],"sourcesContent":["/**\n * Canonical bytes and digests for durable journal rows.\n *\n * Serialization is RFC 8785 through `@tangle-network/agent-interface` — the\n * stack's single identity scheme — so a value carries the same digest in every\n * package that produces or verifies one.\n *\n * Values canonical JSON cannot represent faithfully are refused, never coerced.\n * `NaN`, `Infinity`, `undefined`, class instances, cycles, and unpaired\n * surrogates each have a lossy encoding that maps distinct records onto one\n * digest, and in a hash chain the digest IS the record's identity: a coercion\n * there is a collision, not a convenience.\n */\n\nimport {\n  canonicalCandidateBytes,\n  canonicalCandidateJson,\n  sha256Bytes,\n} from '@tangle-network/agent-interface'\nimport { ValidationError } from '../errors'\n\nexport type LedgerHash = `sha256:${string}`\n\n/** Shape of every ledger digest: `sha256:` followed by 64 lowercase hex chars. */\nexport const LEDGER_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/\n\n/** A value has no faithful canonical-JSON form, so it cannot be stored or hashed. */\nexport class LedgerCanonicalizationError extends ValidationError {}\n\n/** Canonical JSON encoding (RFC 8785): object keys sorted by UTF-16 code unit,\n * recursively. This is the byte form that is hashed and stored, so equal values\n * always encode identically. */\nexport function canonicalString(value: unknown): string {\n  try {\n    return canonicalCandidateJson(value)\n  } catch (error) {\n    throw canonicalizationError(value, error)\n  }\n}\n\nexport function hashCanonical(value: unknown): LedgerHash {\n  try {\n    return sha256Bytes(canonicalCandidateBytes(value))\n  } catch (error) {\n    throw canonicalizationError(value, error)\n  }\n}\n\n/** Name the offending value and path so a refusal is actionable. The RFC 8785\n * encoder above is the sole authority on acceptance; this walk only explains a\n * rejection it already made. */\nfunction canonicalizationError(value: unknown, cause: unknown): LedgerCanonicalizationError {\n  const defect = firstNonCanonicalDefect(value, '$', new Set())\n  const reason = defect !== '' ? defect : cause instanceof Error ? cause.message : String(cause)\n  return new LedgerCanonicalizationError(`value has no canonical JSON form: ${reason}`, {\n    cause,\n  })\n}\n\nfunction firstNonCanonicalDefect(value: unknown, path: string, ancestors: Set<object>): string {\n  if (value === null) return ''\n  if (value === undefined) return `${path} is undefined`\n  const type = typeof value\n  if (type === 'number') {\n    return Number.isFinite(value) ? '' : `${path} is ${String(value)}`\n  }\n  if (type === 'string') {\n    return isWellFormedUtf16(value as string) ? '' : `${path} contains an unpaired surrogate`\n  }\n  if (type === 'boolean') return ''\n  if (type !== 'object') return `${path} is a ${type}`\n  const object = value as object\n  if (ancestors.has(object)) return `${path} closes a reference cycle`\n  const prototype = Object.getPrototypeOf(object)\n  if (!Array.isArray(object) && prototype !== Object.prototype && prototype !== null) {\n    return `${path} is a ${object.constructor?.name ?? 'non-plain'} instance, not plain JSON data`\n  }\n  const nested = new Set(ancestors).add(object)\n  if (Array.isArray(object)) {\n    for (let index = 0; index < object.length; index += 1) {\n      const defect = firstNonCanonicalDefect(object[index], `${path}[${index}]`, nested)\n      if (defect !== '') return defect\n    }\n    return ''\n  }\n  for (const [key, entry] of Object.entries(object)) {\n    if (!isWellFormedUtf16(key)) return `${path}.${key} has a key with an unpaired surrogate`\n    const defect = firstNonCanonicalDefect(entry, `${path}.${key}`, nested)\n    if (defect !== '') return defect\n  }\n  return ''\n}\n\nfunction isWellFormedUtf16(value: string): boolean {\n  for (let index = 0; index < value.length; index += 1) {\n    const code = value.charCodeAt(index)\n    if (code >= 0xd800 && code <= 0xdbff) {\n      const next = value.charCodeAt(index + 1)\n      if (!(next >= 0xdc00 && next <= 0xdfff)) return false\n      index += 1\n    } else if (code >= 0xdc00 && code <= 0xdfff) {\n      return false\n    }\n  }\n  return true\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAwBA,MAAa,sBAAsB;;AAGnC,IAAa,8BAAb,cAAiD,gBAAgB,CAAC;;;;AAKlE,SAAgB,gBAAgB,OAAwB;CACtD,IAAI;EACF,OAAO,uBAAuB,KAAK;CACrC,SAAS,OAAO;EACd,MAAM,sBAAsB,OAAO,KAAK;CAC1C;AACF;AAEA,SAAgB,cAAc,OAA4B;CACxD,IAAI;EACF,OAAO,YAAY,wBAAwB,KAAK,CAAC;CACnD,SAAS,OAAO;EACd,MAAM,sBAAsB,OAAO,KAAK;CAC1C;AACF;;;;AAKA,SAAS,sBAAsB,OAAgB,OAA6C;CAC1F,MAAM,SAAS,wBAAwB,OAAO,qBAAK,IAAI,IAAI,CAAC;CAE5D,OAAO,IAAI,4BAA4B,qCADxB,WAAW,KAAK,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,KACP,EACpF,MACF,CAAC;AACH;AAEA,SAAS,wBAAwB,OAAgB,MAAc,WAAgC;CAC7F,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,UAAU,KAAA,GAAW,OAAO,GAAG,KAAK;CACxC,MAAM,OAAO,OAAO;CACpB,IAAI,SAAS,UACX,OAAO,OAAO,SAAS,KAAK,IAAI,KAAK,GAAG,KAAK,MAAM,OAAO,KAAK;CAEjE,IAAI,SAAS,UACX,OAAO,kBAAkB,KAAe,IAAI,KAAK,GAAG,KAAK;CAE3D,IAAI,SAAS,WAAW,OAAO;CAC/B,IAAI,SAAS,UAAU,OAAO,GAAG,KAAK,QAAQ;CAC9C,MAAM,SAAS;CACf,IAAI,UAAU,IAAI,MAAM,GAAG,OAAO,GAAG,KAAK;CAC1C,MAAM,YAAY,OAAO,eAAe,MAAM;CAC9C,IAAI,CAAC,MAAM,QAAQ,MAAM,KAAK,cAAc,OAAO,aAAa,cAAc,MAC5E,OAAO,GAAG,KAAK,QAAQ,OAAO,aAAa,QAAQ,YAAY;CAEjE,MAAM,SAAS,IAAI,IAAI,SAAS,CAAC,CAAC,IAAI,MAAM;CAC5C,IAAI,MAAM,QAAQ,MAAM,GAAG;EACzB,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,QAAQ,SAAS,GAAG;GACrD,MAAM,SAAS,wBAAwB,OAAO,QAAQ,GAAG,KAAK,GAAG,MAAM,IAAI,MAAM;GACjF,IAAI,WAAW,IAAI,OAAO;EAC5B;EACA,OAAO;CACT;CACA,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAAG;EACjD,IAAI,CAAC,kBAAkB,GAAG,GAAG,OAAO,GAAG,KAAK,GAAG,IAAI;EACnD,MAAM,SAAS,wBAAwB,OAAO,GAAG,KAAK,GAAG,OAAO,MAAM;EACtE,IAAI,WAAW,IAAI,OAAO;CAC5B;CACA,OAAO;AACT;AAEA,SAAS,kBAAkB,OAAwB;CACjD,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EACpD,MAAM,OAAO,MAAM,WAAW,KAAK;EACnC,IAAI,QAAQ,SAAU,QAAQ,OAAQ;GACpC,MAAM,OAAO,MAAM,WAAW,QAAQ,CAAC;GACvC,IAAI,EAAE,QAAQ,SAAU,QAAQ,QAAS,OAAO;GAChD,SAAS;EACX,OAAO,IAAI,QAAQ,SAAU,QAAQ,OACnC,OAAO;CAEX;CACA,OAAO;AACT"}

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { o as runRolloutReleaseCli } from "./hf-dataset-DBJXXoY1.js";
-import { n as runAnalystBenchmarkCommand } from "./benchmark-command-CMqVqReF.js";
-import { a as runRpcBatch, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi } from "./server-DLEvyW2z.js";
+import { o as runRolloutReleaseCli } from "./hf-dataset-XggBupCr.js";
+import { n as runAnalystBenchmarkCommand } from "./benchmark-command-BKfjOBJ5.js";
+import { a as runRpcBatch, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi } from "./server-DaCpLfi0.js";
 import { writeFileSync } from "node:fs";
 //#region src/cli-config.ts
 function resolveCliLlmConfig(env = process.env) {

package/dist/{client-BwPKohkJ.d.ts → client-BohnDFBq.d.ts}

@@ -1,6 +1,6 @@
-import { l as RunTerminalOutcome } from "./run-record-DwHMk1Ai.js";
-import { _ as GateDecision, j as MutableSurface } from "./types-zFYez3PK.js";
-import { o as InsightReport } from "./insight-report-CXd8VBDR.js";
+import { l as RunTerminalOutcome } from "./run-record-CztDMXVF.js";
+import { _ as GateDecision, j as MutableSurface } from "./types-BBFNHxSK.js";
+import { o as InsightReport } from "./insight-report-Bu5Wi9tG.js";
 //#region src/hosted/types.d.ts
 declare const HOSTED_WIRE_VERSION: '2026-07-24.v1';
 type HostedWireVersion = typeof HOSTED_WIRE_VERSION;
@@ -199,4 +199,4 @@ declare function hostedClientFromEnv(overrides?: Partial<HostedTenant> & {
 }): HostedClient | undefined;
 //#endregion
 export { UnixNanoTimestamp as _, hostedTenantFromEnv as a, EvalRunGenerationSnapshot as c, HostedIngestHeaders as d, HostedWireVersion as f, TraceSpanEvent as g, IngestTracesRequest as h, hostedClientFromEnv as i, EvalRunStatus as l, IngestResponse as m, HostedTenant as n, EvalRunCellScore as o, IngestEvalRunsRequest as p, createHostedClient as r, EvalRunEvent as s, HostedClient as t, HOSTED_WIRE_VERSION as u };
-//# sourceMappingURL=client-BwPKohkJ.d.ts.map
+//# sourceMappingURL=client-BohnDFBq.d.ts.map

package/dist/{client-BwPKohkJ.d.ts.map → client-BohnDFBq.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"client-BwPKohkJ.d.ts","names":[],"sources":["../src/hosted/types.ts","../src/hosted/client.ts"],"mappings":";;;;cAgCa;KACD,2BAA2B;;UAKtB;;EAEf;;EAEA;;EAEA,yBAAyB;;EAEzB;;;KAMU;UAQK;;EAEf;;EAEA;;EAEA;;EAEA,YAAY,eAAe;;EAE3B,iBAAiB;;EAEjB;;EAEA;;UAGe;;EAEf;;;EAGA;;;EAGA,UAAU;;EAEV,OAAO;;EAEP;;EAEA;;EAEA;;;;;;;UAQe;;EAEf;;EAEA;;EAEA;;EAEA,QAAQ;;EAER,QAAQ;;EAER,WAAW;;EAEX,aAAa;;EAEb,eAAe;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;EAMA,gBAAgB;;;;;;KASN;;;;;;UAOK;EACf;EACA;EACA;EACA;EACA,mBAAmB;EACnB,iBAAiB;EACjB,YAAY;EACZ,SAAS;IACP,cAAc;IACd;IACA,aAAa;;EAEf;IAAW;IAAgC;;;EAE3C;;EAEA;;EAEA;;EAEA;;UAKe;EACf,aAAa;EACb,QAAQ;;UAGO;EACf,aAAa;EACb,OAAO;;UAGQ;;EAEf;;EAEA,UAAU;IAAQ;IAAe;;;;;UC1JlB;;EAEf;;EAEA;;EAEA;;EAEA,mBAAmB;;EAEnB;;EAEA;;UAGe;EACf,cAAc,OAAO,cAAc,0BAA0B,QAAQ;EACrE,eAAe,QAAQ,gBAAgB,0BAA0B,QAAQ;EACzE,aAAa,OAAO,kBAAkB,0BAA0B,QAAQ;WAC/D,QAAQ;WACR,aAAa;;iBAyGR,mBAAmB,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsE1C,oBACd,YAAW,QAAQ;EAAkB,MAAM;IAC1C;iBAiBa,oBACd,YAAW,QAAQ;EAAkB,MAAM;IAC1C"}
+{"version":3,"file":"client-BohnDFBq.d.ts","names":[],"sources":["../src/hosted/types.ts","../src/hosted/client.ts"],"mappings":";;;;cAgCa;KACD,2BAA2B;;UAKtB;;EAEf;;EAEA;;EAEA,yBAAyB;;EAEzB;;;KAMU;UAQK;;EAEf;;EAEA;;EAEA;;EAEA,YAAY,eAAe;;EAE3B,iBAAiB;;EAEjB;;EAEA;;UAGe;;EAEf;;;EAGA;;;EAGA,UAAU;;EAEV,OAAO;;EAEP;;EAEA;;EAEA;;;;;;;UAQe;;EAEf;;EAEA;;EAEA;;EAEA,QAAQ;;EAER,QAAQ;;EAER,WAAW;;EAEX,aAAa;;EAEb,eAAe;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;EAMA,gBAAgB;;;;;;KASN;;;;;;UAOK;EACf;EACA;EACA;EACA;EACA,mBAAmB;EACnB,iBAAiB;EACjB,YAAY;EACZ,SAAS;IACP,cAAc;IACd;IACA,aAAa;;EAEf;IAAW;IAAgC;;;EAE3C;;EAEA;;EAEA;;EAEA;;UAKe;EACf,aAAa;EACb,QAAQ;;UAGO;EACf,aAAa;EACb,OAAO;;UAGQ;;EAEf;;EAEA,UAAU;IAAQ;IAAe;;;;;UC1JlB;;EAEf;;EAEA;;EAEA;;EAEA,mBAAmB;;EAEnB;;EAEA;;UAGe;EACf,cAAc,OAAO,cAAc,0BAA0B,QAAQ;EACrE,eAAe,QAAQ,gBAAgB,0BAA0B,QAAQ;EACzE,aAAa,OAAO,kBAAkB,0BAA0B,QAAQ;WAC/D,QAAQ;WACR,aAAa;;iBAyGR,mBAAmB,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsE1C,oBACd,YAAW,QAAQ;EAAkB,MAAM;IAC1C;iBAiBa,oBACd,YAAW,QAAQ;EAAkB,MAAM;IAC1C"}

package/dist/{completion-verifier-B4-IMYcS.d.ts → completion-verifier-IPoP4fQO.d.ts}

@@ -1,6 +1,180 @@
 import { t as DefaultVerdict } from "./verdict-Dps8_okt.js";
-import { c as CostLedgerHandle } from "./cost-ledger-B1D3COAc.js";
-import { A as ChatClient, _t as RawProviderSink } from "./types-5q2T25iW.js";
+import { c as CostLedgerHandle } from "./cost-ledger-DKgyIWRj.js";
+import { A as ChatClient, _t as RawProviderSink } from "./types-uPrS6mD-.js";
+import { c as AnalystRunInputs, i as AnalystFinding, l as AnalystRunResult, n as AnalystContext, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary } from "./types-DoEYskCd.js";
+import { i as ExactAnalystRunEvent, o as ExactAnalystRunResult, u as ExactExecutionComponentIdentity } from "./exact-types-MaaFcllV.js";
+//#region src/analyst/registry.d.ts
+interface AnalystHooks {
+  /** Legacy runs may mutate ctx; exact runs provide a frozen observational context. */
+  onBeforeAnalyze?(args: {
+    analyst: Analyst;
+    ctx: AnalystContext;
+    runId: string;
+  }): void | Promise<void>;
+  /** After every analyst (ok | failed | skipped). Use for telemetry, ingestion, rotation. */
+  onAfterAnalyze?(args: {
+    analyst: Analyst;
+    summary: AnalystRunSummary;
+    findings: AnalystFinding[];
+    runId: string;
+  }): void | Promise<void>;
+  /**
+   * On analyst exception. Hook MAY return findings to convert the
+   * error into structured findings; the summary still reports 'failed'.
+   * Return void to keep the default empty-findings behavior.
+   */
+  onError?(args: {
+    analyst: Analyst;
+    error: Error;
+    runId: string;
+  }): AnalystFinding[] | undefined | Promise<AnalystFinding[] | undefined>;
+  /** Once after registry.run() completes. Use for final aggregation, persistence. */
+  onComplete?(args: {
+    result: AnalystRunResult;
+  }): void | Promise<void>;
+}
+interface BudgetPolicy {
+  /** Overall USD cap across the registry.run(). */
+  totalUsd?: number;
+  /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
+  weights?: Record<string, number>;
+  /**
+   * Custom allocator — receives the analyst, remaining/total budget, and
+   * the count of analysts that will run. Returns the per-analyst budget
+   * (or undefined only when the run has no overall cap). Overrides weights
+   * when set.
+   */
+  allocate?: (args: {
+    analyst: Analyst;
+    totalUsd: number | undefined;
+    remainingUsd: number | undefined;
+    runningCount: number;
+  }) => number | undefined;
+}
+interface AnalystRegistryOptions {
+  /** Shared chat client passed to every LLM analyst via AnalystContext. */
+  chat?: ChatClient;
+  /** Logger callback. Defaults to a no-op. */
+  log?: (msg: string, fields?: Record<string, unknown>) => void;
+  /** Hooks invoked around analyze() — observability + customization seam. */
+  hooks?: AnalystHooks;
+  /** Required identity/config when `runExact` applies `hooks`. */
+  hooksIdentity?: ExactExecutionComponentIdentity;
+  /** Default budget when run() doesn't override. */
+  defaultBudget?: BudgetPolicy;
+  /** Required identity/config when `runExact` provides `chat`. */
+  chatIdentity?: ExactExecutionComponentIdentity;
+}
+interface RegistryRunOpts {
+  /** Restrict to a subset of registered analysts by id. */
+  only?: string[];
+  /** Skip these analysts even if registered. Useful for cheap iteration. */
+  skip?: string[];
+  /** Budget policy — totalUsd + optional weights/allocator. Falls back to options.defaultBudget. */
+  budget?: BudgetPolicy;
+  /** Active-work cap for the complete registry run. Model receipt settlement may follow. */
+  timeoutMs?: number;
+  /** Abort signal — forwarded into every analyst's context. */
+  signal?: AbortSignal;
+  /** Shared paid-call account forwarded to every analyst. */
+  costLedger?: CostLedgerHandle;
+  /** Attribution phase for calls written to `costLedger`. */
+  costPhase?: string;
+  /** Tags echoed into AnalystContext.tags — useful for tracking environment/version in findings. */
+  tags?: Record<string, string>;
+  /**
+   * Prior-run findings made available as retrieval context to every
+   * analyst via `ctx.priorFindings`. The registry forwards the slice
+   * whose `analyst_id` matches each registered analyst so a kind sees
+   * only its own history. Pass `{ '*': findings }` to broadcast to
+   * every analyst (useful when several kinds share the same historical
+   * context). For findings from this run, use `chainFindings` instead.
+   */
+  priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>;
+  /**
+   * Pass findings produced earlier in this registry run to each later analyst
+   * via `ctx.upstreamFindings`. Registration order is dependency order.
+   * Disabled by default because independent analyst suites must opt in.
+   */
+  chainFindings?: boolean;
+}
+/** A caller-selected allocation rule for an exact analyst run. */
+type ExactAnalystBudgetPolicy = {
+  readonly kind: 'equal';
+  readonly totalUsd: number;
+} | {
+  readonly kind: 'weighted';
+  readonly totalUsd: number;
+  /** One explicit weight for every selected analyst id. */
+  readonly weights: Readonly<Record<string, number>>;
+};
+/**
+ * Complete per-run analyst policy.
+ *
+ * Every field is required. `null` explicitly disables an optional resource or context channel.
+ * `analystIds` is execution order; it is not filtered through registry insertion order.
+ * Missing-input behavior is explicit so callers cannot accidentally inherit it by omission.
+ * Exact runs are serial; more elaborate scheduling belongs in the caller's runtime.
+ */
+interface ExactRegistryRunOpts {
+  readonly analystIds: readonly string[];
+  readonly budget: ExactAnalystBudgetPolicy | null;
+  readonly totalTimeoutMs: number | null;
+  readonly signal: AbortSignal | null;
+  readonly costLedger: CostLedgerHandle | null;
+  readonly costLedgerIdentity: ExactExecutionComponentIdentity | null;
+  readonly costPhase: string | null;
+  readonly tags: Readonly<Record<string, string>> | null;
+  readonly priorFindings: ReadonlyArray<AnalystFinding> | Readonly<Record<string, ReadonlyArray<AnalystFinding>>> | null;
+  readonly chainFindings: boolean;
+  readonly missingInputMode: 'skip' | 'abort';
+  readonly applyRegistryHooks: boolean;
+  readonly useRegistryChat: boolean;
+}
+/** A post-start exact-run failure; completed work remains attached for accounting and review. */
+declare class ExactAnalystRunExecutionError extends Error {
+  readonly name: string;
+  readonly result: ExactAnalystRunResult;
+  constructor(message: string, result: ExactAnalystRunResult, options?: ErrorOptions);
+}
+declare class AnalystRegistry {
+  private readonly analysts;
+  private readonly options;
+  constructor(options?: AnalystRegistryOptions);
+  register(analyst: Analyst): void;
+  list(): ReadonlyArray<{
+    id: string;
+    description: string;
+    version: string;
+    cost: Analyst['cost'];
+  }>;
+  run(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): Promise<AnalystRunResult>;
+  /** Run exactly the ordered analysts and complete policy supplied by the caller. */
+  runExact(runId: string, inputs: AnalystRunInputs, runOpts: ExactRegistryRunOpts): Promise<ExactAnalystRunResult>;
+  /** Streaming counterpart to {@link runExact}. */
+  runExactStream(runId: string, inputs: AnalystRunInputs, runOpts: ExactRegistryRunOpts): AsyncGenerator<ExactAnalystRunEvent, void, void>;
+  /**
+   * Streaming counterpart to `run()`. Emits `AnalystRunEvent` values
+   * in real time — `run-started`, then per-analyst `skipped` /
+   * `started` / `completed`, then a terminal `run-completed` whose
+   * payload is the full `AnalystRunResult`. UIs use this to render
+   * progress; persistence consumers use `run()` and read the result.
+   *
+   * Hooks (`onBeforeAnalyze` / `onAfterAnalyze` / `onError` /
+   * `onComplete`) fire as before — streaming is additive, not a hook
+   * replacement.
+   */
+  runStream(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): AsyncGenerator<AnalystRunEvent, void, void>;
+  private normalizeLegacyPlan;
+  private normalizeExactPlan;
+  private executePlanStream;
+  private selectAnalysts;
+  private selectExactAnalysts;
+  private routeInput;
+}
+/** Validate the canonical exact-run policy before any analyst can start. */
+declare function assertExactRegistryRunOpts(value: unknown): asserts value is ExactRegistryRunOpts;
+//#endregion
 //#region src/artifact-validator.d.ts
 /**
  * Artifact validators.
@@ -236,5 +410,5 @@ declare function createTokenRecallChecker(opts?: {
   minContentLength?: number;
 }): CorrectnessChecker;
 //#endregion
-export { jsonHasKeys as C, containsAll as S, ValidationContext as _, ProducedProposal as a, byteLengthRange as b, SatisfiedBy as c, createLlmCorrectnessChecker as d, createTokenRecallChecker as f, ArtifactValidator as g, Artifact as h, LlmCorrectnessCheckerOpts as i, TaskGold as l, verifyCompletion as m, CompletionVerdict as n, ProducedState as o, parseCorrectnessResponse as p, CorrectnessChecker as r, RequirementCheck as s, CompletionRequirement as t, completionVerdict as u, ValidationIssue as v, regexMatch as w, composeValidators as x, ValidationResult as y };
-//# sourceMappingURL=completion-verifier-B4-IMYcS.d.ts.map
+export { ExactAnalystRunExecutionError as A, jsonHasKeys as C, AnalystRegistryOptions as D, AnalystRegistry as E, RegistryRunOpts as M, assertExactRegistryRunOpts as N, BudgetPolicy as O, containsAll as S, AnalystHooks as T, ValidationContext as _, ProducedProposal as a, byteLengthRange as b, SatisfiedBy as c, createLlmCorrectnessChecker as d, createTokenRecallChecker as f, ArtifactValidator as g, Artifact as h, LlmCorrectnessCheckerOpts as i, ExactRegistryRunOpts as j, ExactAnalystBudgetPolicy as k, TaskGold as l, verifyCompletion as m, CompletionVerdict as n, ProducedState as o, parseCorrectnessResponse as p, CorrectnessChecker as r, RequirementCheck as s, CompletionRequirement as t, completionVerdict as u, ValidationIssue as v, regexMatch as w, composeValidators as x, ValidationResult as y };
+//# sourceMappingURL=completion-verifier-IPoP4fQO.d.ts.map

package/dist/completion-verifier-IPoP4fQO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-verifier-IPoP4fQO.d.ts","names":[],"sources":["../src/analyst/registry.ts","../src/artifact-validator.ts","../src/completion-verifier.ts"],"mappings":"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"}

package/dist/contract/index.d.ts

@@ -1,14 +1,14 @@
-import { c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt } from "../cost-ledger-B1D3COAc.js";
-import { a as RunRecord, n as RunCostProvenance, s as RunSplitTag } from "../run-record-DwHMk1Ai.js";
-import { A as ChatClient, F as CreateChatClientOpts, V as createChatClient } from "../types-5q2T25iW.js";
-import { h as ProposalFindingOrigin, i as AnalystFinding, m as ProposalFinding, v as makeProposalFinding } from "../types-BtJhn8v6.js";
-import { n as buildDefaultAnalystRegistry, t as DefaultAnalystRegistryOptions } from "../default-registry-PUhIVRWz.js";
-import { C as JudgeDimension, H as SurfaceProposer, M as OptimizerConfig, R as Scenario, S as JudgeConfig, V as SessionScript, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, h as GateContext, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, m as GateCheckStatus, n as CampaignArtifactWriter, p as Gate, r as CampaignCellResult, t as CampaignAggregates, v as GateResult, w as JudgeScore, y as GenerationCandidate } from "../types-zFYez3PK.js";
-import { A as RunEvalOptions, B as OptimizerModelBudget, Bt as ComparisonCost, C as RunImprovementLoopOptions, Cn as ReferenceEquivalenceJudgeResult, D as RunOptimizationOptions, Dn as LlmJudgeDimension, E as PremeasuredOptimizationBaseline, En as runReferenceEquivalenceJudge, F as GepaOptimizationMethodConfig, Ft as ExternalTextOptimizerContext, G as ObjectiveSource, Gt as OptimizationMethodProvenance, H as AxisVerdict, Ht as OptimizationMethodComparison, I as GepaOptimizationRecipe, It as ExternalTextOptimizerResult, J as PromotionPolicy, K as ParetoSignificanceGateOptions, Kt as OptimizationMethodResult, L as GepaRunnerCommand, Lt as ExternalOptimizationExample, M as GepaAdaptiveEngineRun, Mt as composeGate, N as GepaEngineOptions, Nt as externalTextOptimizationMethod, On as LlmJudgeOptions, P as GepaEngineRun, Pt as ExternalTextOptimizationMethodConfig, R as gepaOptimizationMethod, Rt as ExternalTextEvaluationResponse, Sn as ReferenceEquivalenceJudgeOptions, T as runImprovementLoop, Tn as createReferenceEquivalenceJudge, U as BuildEvidenceVectorOptions, Ut as OptimizationMethodInput, V as AxisEvidence, Vt as OptimizationMethod, W as EvidenceVector, X as paretoPolicy, Xt as OptimizationTokenUsage, Y as buildEvidenceVector, Yt as OptimizationPackageSource, Z as paretoSignificanceGate, Zt as compareOptimizationMethods, bn as REFERENCE_EQUIVALENCE_JUDGE_VERSION, dt as DefaultProductionGateCheck, en as CampaignCellFailureReceipt, ft as DefaultProductionGateOptions, i as skillOptOptimizationMethod, in as RunCampaignOptions, j as runEval, kn as llmJudge, ln as fsCampaignStorage, lt as HeldOutGateOptions, mn as campaignSplitDigest, mt as defaultProductionGate, n as SkillOptRunnerCommand, on as runCampaign, ot as PowerPreflight, p as LoopProvenanceRecord, pt as DefaultProductionRewardHackingOptions, q as PromotionObjective, r as SkillOptTrainerConfig, sn as CampaignStorage, t as SkillOptOptimizationMethodConfig, un as inMemoryCampaignStorage, ut as heldOutGate, w as RunImprovementLoopResult, wn as ReferenceEquivalenceScenario, xn as ReferenceEquivalenceJudgeInput, yn as REFERENCE_EQUIVALENCE_INPUT_LIMITS, z as OpenAICompatibleOptimizerModel, zt as CompareOptimizationMethodsOptions } from "../skillopt-optimization-method-CzfnA8O-.js";
-import { a as FailureClusterInsight, c as JudgeInsight, d as Recommendation, f as ReleaseSummary, i as FailureClassTally, l as LiftInsight, m as TokenUsageInsight, n as ExecutionErrorOutcomeCell, o as InsightReport, p as ScalarDistribution, r as ExecutionInsight, s as InterRaterInsight, t as CostProvenanceSummary, u as OutcomeCorrelationInsight } from "../insight-report-CXd8VBDR.js";
-import { c as EvalRunGenerationSnapshot, g as TraceSpanEvent, n as HostedTenant, o as EvalRunCellScore, s as EvalRunEvent } from "../client-BwPKohkJ.js";
+import { c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt } from "../cost-ledger-DKgyIWRj.js";
+import { a as RunRecord, n as RunCostProvenance, s as RunSplitTag } from "../run-record-CztDMXVF.js";
+import { A as ChatClient, F as CreateChatClientOpts, V as createChatClient } from "../types-uPrS6mD-.js";
+import { h as ProposalFindingOrigin, i as AnalystFinding, m as ProposalFinding, v as makeProposalFinding } from "../types-DoEYskCd.js";
+import { n as buildDefaultAnalystRegistry, t as DefaultAnalystRegistryOptions } from "../default-registry-B8vf7Rmf.js";
+import { C as JudgeDimension, H as SurfaceProposer, M as OptimizerConfig, R as Scenario, S as JudgeConfig, V as SessionScript, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, h as GateContext, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, m as GateCheckStatus, n as CampaignArtifactWriter, p as Gate, r as CampaignCellResult, t as CampaignAggregates, v as GateResult, w as JudgeScore, y as GenerationCandidate } from "../types-BBFNHxSK.js";
+import { a as FailureClusterInsight, c as JudgeInsight, d as Recommendation, f as ReleaseSummary, i as FailureClassTally, l as LiftInsight, m as TokenUsageInsight, n as ExecutionErrorOutcomeCell, o as InsightReport, p as ScalarDistribution, r as ExecutionInsight, s as InterRaterInsight, t as CostProvenanceSummary, u as OutcomeCorrelationInsight } from "../insight-report-Bu5Wi9tG.js";
+import { A as summarizeExecution, D as ExecutionReport, E as AnalyzeRunsOptions, O as SummarizeExecutionOptions, k as analyzeRuns } from "../tool-groups-CdYq22lX.js";
+import { A as RunEvalOptions, B as OptimizerModelBudget, Bt as ComparisonCost, C as RunImprovementLoopOptions, Cn as ReferenceEquivalenceJudgeResult, D as RunOptimizationOptions, Dn as LlmJudgeDimension, E as PremeasuredOptimizationBaseline, En as runReferenceEquivalenceJudge, F as GepaOptimizationMethodConfig, Ft as ExternalTextOptimizerContext, G as ObjectiveSource, Gt as OptimizationMethodProvenance, H as AxisVerdict, Ht as OptimizationMethodComparison, I as GepaOptimizationRecipe, It as ExternalTextOptimizerResult, J as PromotionPolicy, K as ParetoSignificanceGateOptions, Kt as OptimizationMethodResult, L as GepaRunnerCommand, Lt as ExternalOptimizationExample, M as GepaAdaptiveEngineRun, Mt as composeGate, N as GepaEngineOptions, Nt as externalTextOptimizationMethod, On as LlmJudgeOptions, P as GepaEngineRun, Pt as ExternalTextOptimizationMethodConfig, R as gepaOptimizationMethod, Rt as ExternalTextEvaluationResponse, Sn as ReferenceEquivalenceJudgeOptions, T as runImprovementLoop, Tn as createReferenceEquivalenceJudge, U as BuildEvidenceVectorOptions, Ut as OptimizationMethodInput, V as AxisEvidence, Vt as OptimizationMethod, W as EvidenceVector, X as paretoPolicy, Xt as OptimizationTokenUsage, Y as buildEvidenceVector, Yt as OptimizationPackageSource, Z as paretoSignificanceGate, Zt as compareOptimizationMethods, bn as REFERENCE_EQUIVALENCE_JUDGE_VERSION, dt as DefaultProductionGateCheck, en as CampaignCellFailureReceipt, ft as DefaultProductionGateOptions, i as skillOptOptimizationMethod, in as RunCampaignOptions, j as runEval, kn as llmJudge, ln as fsCampaignStorage, lt as HeldOutGateOptions, mn as campaignSplitDigest, mt as defaultProductionGate, n as SkillOptRunnerCommand, on as runCampaign, ot as PowerPreflight, p as LoopProvenanceRecord, pt as DefaultProductionRewardHackingOptions, q as PromotionObjective, r as SkillOptTrainerConfig, sn as CampaignStorage, t as SkillOptOptimizationMethodConfig, un as inMemoryCampaignStorage, ut as heldOutGate, w as RunImprovementLoopResult, wn as ReferenceEquivalenceScenario, xn as ReferenceEquivalenceJudgeInput, yn as REFERENCE_EQUIVALENCE_INPUT_LIMITS, z as OpenAICompatibleOptimizerModel, zt as CompareOptimizationMethodsOptions } from "../skillopt-optimization-method-_s0Tub7Y.js";
+import { c as EvalRunGenerationSnapshot, g as TraceSpanEvent, n as HostedTenant, o as EvalRunCellScore, s as EvalRunEvent } from "../client-BohnDFBq.js";
 import { i as InMemoryOutcomeStore, n as FileSystemOutcomeStore, o as OutcomeStore, r as FileSystemOutcomeStoreOptions, t as DeploymentOutcome } from "../outcome-store-BYHIuO0e.js";
-import { a as summarizeExecution, i as analyzeRuns, n as ExecutionReport, r as SummarizeExecutionOptions, t as AnalyzeRunsOptions } from "../analyze-runs-CPYxfPWT.js";
 import { AgentCandidateBenchmarkCellRef, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkTaskMaterial, AgentCandidateBundle, AgentCandidateEvaluationPolicy, AgentCandidateExperiment, AgentCandidateExperimentMaterial, AgentCandidateExperimentMeasurement, AgentImprovementCost, AgentImprovementMeasuredComparison, AgentProfileImprovementExperiment, AgentProfileImprovementExperimentMaterial, AgentProfileImprovementMeasuredComparison, AgentProfileImprovementMeasurement, AgentProfileImprovementRunCell, AgentProfileImprovementRunReceipt, AgentProfileImprovementSuiteInputs, AgentProfileImprovementTask, AgentProfileImprovementTaskMaterial, CandidateExecutionEvidence, Sha256Digest } from "@tangle-network/agent-interface";
 //#region src/contract/self-improve.d.ts
 interface SelfImproveBudget {

package/dist/contract/index.js

@@ -1,15 +1,16 @@
 import { c as ValidationError } from "../errors-D-LKuDhb.js";
-import { G as createChatClient, t as buildDefaultAnalystRegistry } from "../default-registry-lp5R0lve.js";
 import { i as estimateCost, o as isModelPriced } from "../metrics-C9YY1OcL.js";
-import { i as CostLedger } from "../cost-ledger-CHDLA0Ss.js";
+import { i as CostLedger } from "../cost-ledger-CZ9diLxY.js";
+import { C as createChatClient, t as buildDefaultAnalystRegistry } from "../default-registry-BgJJItGr.js";
 import { LLM_MODEL_ATTR_KEYS, SPAN_KIND_ATTR_KEYS } from "../trace-attributes.js";
-import { A as classifyOtlpSpanRole, j as isOtlpModelCall } from "../store-otlp-BenKynPE.js";
-import { h as makeProposalFinding, i as inMemoryCampaignStorage, n as createRunCostLedger, r as fsCampaignStorage } from "../single-run-lock-D_bS5xhj.js";
-import { m as mapConcurrentRange } from "../ledger-core-C0Yx1I14.js";
-import { A as assertOptimizationResult, B as surfaceHash, Dt as decidePairedPromotion, J as runCampaign, O as composeGate, S as defaultProductionGate, T as heldoutSignificance, Y as resolveRunDir, _ as buildEvidenceVector, a as emitLoopProvenance, at as createReferenceEquivalenceJudge, b as powerPreflight, d as runImprovementLoop, et as campaignSplitDigest, g as gepaOptimizationMethod, ht as llmJudge, it as REFERENCE_EQUIVALENCE_JUDGE_VERSION, j as compareOptimizationMethods, k as externalTextOptimizationMethod, o as loopProvenanceArgsFromResult, ot as runReferenceEquivalenceJudge, p as runEval, rt as REFERENCE_EQUIVALENCE_INPUT_LIMITS, t as skillOptOptimizationMethod, v as paretoPolicy, x as heldOutGate, y as paretoSignificanceGate, z as surfaceContentHash } from "../skillopt-optimization-method-CjKMZy0d.js";
+import { nt as classifyOtlpSpanRole, rt as isOtlpModelCall } from "../kind-factory-CFxA0JQX.js";
+import { s as makeProposalFinding } from "../usage-receipt-CgxMEBZq.js";
+import { i as inMemoryCampaignStorage, n as createRunCostLedger, r as fsCampaignStorage } from "../single-run-lock-BTTtPZ9N.js";
+import { m as mapConcurrentRange } from "../ledger-core-Dxz0Rkwa.js";
+import { A as assertOptimizationResult, B as surfaceHash, Dt as decidePairedPromotion, J as runCampaign, O as composeGate, S as defaultProductionGate, T as heldoutSignificance, Y as resolveRunDir, _ as buildEvidenceVector, a as emitLoopProvenance, at as createReferenceEquivalenceJudge, b as powerPreflight, d as runImprovementLoop, et as campaignSplitDigest, g as gepaOptimizationMethod, ht as llmJudge, it as REFERENCE_EQUIVALENCE_JUDGE_VERSION, j as compareOptimizationMethods, k as externalTextOptimizationMethod, o as loopProvenanceArgsFromResult, ot as runReferenceEquivalenceJudge, p as runEval, rt as REFERENCE_EQUIVALENCE_INPUT_LIMITS, t as skillOptOptimizationMethod, v as paretoPolicy, x as heldOutGate, y as paretoSignificanceGate, z as surfaceContentHash } from "../skillopt-optimization-method-BbGnCC53.js";
 import { E as pairedBootstrap } from "../statistics-ByxzSiOM.js";
 import { i as parseRunRecordSafe, r as modelHasSnapshot } from "../run-record-vRgqWmJw.js";
-import { a as recordAggregateMeasurements, i as readTaskFailureLabels, o as summarizeExecutionMeasurements, s as summarizeTraceErrors, t as extractUsage } from "../extract-usage-CS391dOE.js";
+import { a as recordAggregateMeasurements, i as readTaskFailureLabels, o as summarizeExecutionMeasurements, s as summarizeTraceErrors, t as extractUsage } from "../extract-usage-DZs601Va.js";
 import { n as summarizeExecution, t as analyzeRuns } from "../analyze-runs-BScZvqMV.js";
 import { a as campaignCellExecutionEvidence, c as campaignCellToRunRecord, o as campaignCellJudgeDimensions, s as campaignCellTaskScore } from "../reward-hacking-GyN0kMd8.js";
 import { n as InMemoryOutcomeStore, t as FileSystemOutcomeStore } from "../outcome-store-ChBKlTd_.js";