@tangle-network/agent-eval 0.189.0 → 0.190.1

package/dist/search-ledger-types-C9anU2DX.d.ts

@@ -0,0 +1,489 @@
+import { t as EvaluationClaim } from "./claim-BGOUqoMq.js";
+import { r as LedgerHash } from "./canonical-CFpojCN5.js";
+import { AgentProfileDiff } from "@tangle-network/agent-interface";
+//#region src/campaign/search-ledger-types.d.ts
+/**
+ * Schema tag every search-ledger entry carries. A ledger written under another
+ * tag, such as the retired `tangle.search-ledger.v1` candidate-slot format, is
+ * refused with its tag named; it is never translated.
+ */
+declare const SEARCH_LEDGER_SCHEMA: 'tangle.search-ledger.2026-09';
+type SearchLedgerHash = LedgerHash;
+type SearchSurfaceKind = 'prompt' | 'tool-contract' | 'runtime-config' | 'memory' | 'knowledge' | 'agent-profile' | 'code' | 'deployment';
+/** What a search's nodes are: a mutable agent surface, or an output artifact. */
+type SearchArtifactKind = SearchSurfaceKind | 'output';
+/** Content-addressed artifact or receipt. Mutable paths are locators only; the
+ * digest and byte length bind the exact bytes. */
+interface SearchArtifactRef {
+  role: string;
+  uri: string;
+  sha256: SearchLedgerHash;
+  byteLength: number;
+}
+/** Repository, dataset, or package source pinned to an immutable commit or
+ * content digest. Branches, tags, and bare package versions are rejected. */
+interface SearchSourceRef {
+  uri: string;
+  revision: string;
+}
+/** A fact the producer does not have, with the reason. Unknown is never 0. */
+interface SearchUnknown {
+  unknown: string;
+}
+/** The model an attempt ran: an immutable snapshot, or a moving alias whose
+ * served snapshot the producer could not observe. */
+type SearchModelIdentity = {
+  provider: string;
+  snapshot: string;
+} | {
+  provider: string;
+  alias: string;
+  unknown: string;
+};
+interface SearchCandidateSurface {
+  surfaceId: string;
+  kind: SearchSurfaceKind;
+  artifact: SearchArtifactRef;
+}
+type SearchOperationKind = 'candidate-generation' | 'analysis' | 'selection' | 'judge' | 'other';
+/** train is the proposer's feedback, selection is private to the policy and
+ * allocator, and test is sealed for the claim. */
+type SearchSplit = 'train' | 'selection' | 'test';
+interface SearchTask {
+  taskId: string;
+  /** The claim's independent unit this task samples. Repeats and sibling
+   * tasks of one unit average inside it before any statistic. */
+  unitId: string;
+  source: SearchSourceRef;
+}
+interface SearchSplitTasks {
+  /** `hashCanonical` of `tasks` in taskId order. */
+  taskSetDigest: SearchLedgerHash;
+  tasks: SearchTask[];
+}
+interface SearchSplits {
+  train: SearchSplitTasks;
+  selection: SearchSplitTasks;
+  test: SearchSplitTasks;
+  /**
+   * True when no test unit is a train or selection unit. A search that ran
+   * with shared units records false, and then its claim cannot ship: a test
+   * run of a seen unit measures a fresh run of a seen task, not an
+   * improvement on unseen ones.
+   */
+  heldOutUnits: boolean;
+}
+interface SearchBudget {
+  /** Hard dollar cap on committed spend plus open reservations; null = none declared. */
+  maxUsd: number | null;
+  maxCells: number | null;
+  maxNodes: number | null;
+  /** ISO time after which the policy stops expanding. */
+  deadline: string | null;
+  maxConcurrency: number | null;
+  /** Held back at start for the root's and finalists' test cells. */
+  reservedClaimUsd: number;
+}
+/** Where a cell ran relative to the search's decisions. */
+type SearchCellStage = 'root' | 'train' | 'screen' | 'rung' | 'claim' | 'external';
+type SearchEdgeOperator = 'seed' | 'draft' | 'improve' | 'debug' | 'merge' | 'derive';
+/**
+ * How an edge's parents are known. `explicit`: the proposer that created the
+ * child emitted the edge. `correlated`: an importer joined an optimizer's own
+ * parent record by content digest. `unknown`: no parent record exists, and the
+ * edge has no parents. Nothing is inferred from timing or order.
+ */
+type SearchEdgeAttribution = 'explicit' | 'correlated' | 'unknown';
+type SearchProposerKind = NonNullable<AgentProfileDiff['source']>['kind'];
+interface SearchProposer {
+  kind: SearchProposerKind;
+  name: string;
+  /** The candidate-generation operation that produced the child, when one was recorded. */
+  operationId: string | null;
+  source: SearchSourceRef;
+}
+interface SearchNodeRef {
+  searchId: string;
+  nodeId: string;
+}
+/** Dollars held for a cell or operation before it runs. `hard`: the lane
+ * enforces the maximum. `estimate`: the lane cannot, and overshoot is recorded. */
+interface SearchReservation {
+  kind: 'hard' | 'estimate';
+  usd: number;
+}
+type SearchTokenAccounting = {
+  status: 'known';
+  inputTokens: number;
+  outputTokens: number;
+  cachedTokens: number;
+} | {
+  status: 'unknown';
+  reason: string;
+};
+type SearchCostAccounting = {
+  status: 'known';
+  usd: number;
+  source: 'provider' | 'pricing-table' | 'free';
+} | {
+  status: 'unknown';
+  /** Proven part of the spend; the total may be higher. */
+  knownLowerBoundUsd: number;
+  reason: string;
+};
+interface SearchAttemptAccounting {
+  tokens: SearchTokenAccounting;
+  cost: SearchCostAccounting;
+}
+interface SearchFailureReason {
+  code: string;
+  message: string;
+}
+/** `failed` is the agent's defect and carries a score; `errored` is the
+ * environment's fault, carries none, and may be retried. */
+type SearchTaskOutcome = {
+  status: 'passed';
+  score: number;
+  metrics: Record<string, number>;
+} | {
+  status: 'failed';
+  score: number;
+  metrics: Record<string, number>;
+  failure: SearchFailureReason;
+} | {
+  status: 'errored';
+  metrics: Record<string, number>;
+  error: SearchFailureReason & {
+    retryable: boolean;
+  };
+};
+type SearchSurfaceEffect = {
+  status: 'measured';
+  metric: string;
+  baselineValue: number;
+  candidateValue: number;
+  delta: number;
+} | {
+  status: 'not-measured';
+  reason: string;
+};
+/** Per-attempt proof that a declared node surface did or did not fire. A
+ * surface without evidence is unobserved, not fired. */
+interface SearchSurfaceEvidence {
+  surfaceId: string;
+  fired: boolean;
+  firingCount: number;
+  effect: SearchSurfaceEffect;
+  evidence: SearchArtifactRef[];
+}
+type SearchTraceRef = {
+  traceId: string;
+  execRunId: string | null;
+  spansWritten: number | null;
+  spansDropped: number | null;
+} | SearchUnknown;
+interface SearchExecutionIdentity {
+  model: SearchModelIdentity;
+  agent: SearchSourceRef;
+  benchmark: SearchSourceRef;
+}
+type SearchEstimateMethod = 'none' | 'insufficient' | 'descriptive' | 'bootstrap';
+/**
+ * A paired contrast of one node against another on shared units. `none` below
+ * 2 pairs, `insufficient` below 6, `descriptive` below 20, `bootstrap` from 20.
+ * `estimateNode` computes it; the ledger records the estimate a decision used.
+ */
+interface NodeEstimate {
+  against: string;
+  split: SearchSplit;
+  /** Units the node scored on the split. */
+  units: number;
+  /** Units both nodes scored: the paired sample. */
+  pairs: number;
+  /** Mean per-unit difference, node minus `against`, in the metric's units.
+   * Null for `none`. */
+  delta: number | null;
+  /** Bootstrap interval on `delta`: spread for `descriptive`, decision grade
+   * for `bootstrap`. Null for `none`, `insufficient` and an indeterminate sample. */
+  interval: [number, number] | null;
+  method: SearchEstimateMethod;
+  /** Exact one-sided sign-test p toward improvement; `descriptive` only. */
+  exactSignP: number | null;
+  /** Every paired delta is equal, so an interval would have zero width and
+   * carries no evidence either way. */
+  indeterminate: boolean;
+  /** Digest of the cells read, which also seeds the bootstrap. */
+  cellSetDigest: SearchLedgerHash;
+  estimator: SearchSourceRef;
+}
+type SearchNodeDecision = {
+  status: 'advanced';
+  rung: number;
+} | {
+  status: 'pruned';
+} | {
+  status: 'invalid';
+} | {
+  status: 'finalist';
+} | {
+  status: 'selected';
+} | {
+  status: 'rejected';
+};
+type SearchNodeStatus = SearchNodeDecision['status'];
+type SearchCloseReason = 'budget' | 'deadline' | 'max-nodes' | 'patience' | 'converged' | 'aborted';
+type SearchCancelReason = 'pruned' | 'budget' | 'deadline' | 'aborted';
+type SearchClaimPower = {
+  adequate: boolean;
+  minimumEffect: number;
+  powerAtMinimumEffect: number;
+  units: number;
+} | SearchUnknown;
+/** The claim made once, on the sealed test split. `selected` names the node the
+ * search keeps: a finalist on `ship`, the root otherwise (or null when the
+ * search keeps nothing). */
+interface SearchClaim {
+  power: SearchClaimPower;
+  finalists: Array<{
+    nodeId: string;
+    estimate: NodeEstimate | null;
+    promote: boolean;
+  }>;
+  selected: string | null;
+  decision: 'ship' | 'hold' | 'test-cannot-resolve';
+}
+interface SearchLedgerEventBase {
+  eventId: string;
+  occurredAt: string;
+  artifacts: SearchArtifactRef[];
+}
+/** First event, once: what is searched, against what, on which tasks, under which budget. */
+interface SearchOpenedEvent extends SearchLedgerEventBase {
+  kind: 'search-opened';
+  /** What the search improves, for example `vb/coder`. */
+  subject: string;
+  process: {
+    name: string;
+    executionRef: SearchSourceRef;
+  };
+  artifactKind: SearchArtifactKind;
+  objective: {
+    metric: string;
+    direction: 'maximize' | 'minimize';
+    judge: SearchSourceRef | SearchUnknown;
+    claim: EvaluationClaim;
+  };
+  splits: SearchSplits;
+  policy: {
+    expansion: string;
+    allocation: string;
+    seed: number;
+  };
+  budget: SearchBudget;
+  /** The cell attempt of another search whose execution runs this one. */
+  containment: {
+    searchId: string;
+    cellId: string;
+    attempt: number;
+  } | null;
+  /** The node of another search this one starts from. */
+  derivedFrom: {
+    searchId: string;
+    nodeId: string;
+    headHash: SearchLedgerHash;
+  } | null;
+  identity: SearchExecutionIdentity;
+}
+interface SearchOperationStartedEvent extends SearchLedgerEventBase {
+  kind: 'operation-started';
+  operationId: string;
+  operationKind: SearchOperationKind;
+  reservation: SearchReservation | null;
+}
+interface SearchOperationRecordedEvent extends SearchLedgerEventBase {
+  kind: 'operation-recorded';
+  operationId: string;
+  operationKind: SearchOperationKind;
+  execution: {
+    kind: 'model';
+    model: SearchModelIdentity;
+    source: SearchSourceRef;
+  } | {
+    kind: 'deterministic';
+    source: SearchSourceRef;
+  };
+  outcome: {
+    status: 'completed';
+  } | {
+    status: 'partial';
+    failure: SearchFailureReason;
+  } | {
+    status: 'failed';
+    failure: SearchFailureReason;
+  };
+  accounting: SearchAttemptAccounting;
+}
+/** A content-addressed artifact enters the search. `nodeId` is
+ * `searchNodeId(searchId, artifactDigest)`, so a re-proposal of identical
+ * content is a second edge into this node, never a second node. */
+interface SearchNodeRegisteredEvent extends SearchLedgerEventBase {
+  kind: 'node-registered';
+  nodeId: string;
+  artifactDigest: SearchLedgerHash;
+  artifact: SearchArtifactRef;
+  surfaces: SearchCandidateSurface[];
+}
+/** The proposal that derived a node from its parents. */
+interface SearchEdgeRecordedEvent extends SearchLedgerEventBase {
+  kind: 'edge-recorded';
+  edgeId: string;
+  childNodeId: string;
+  /** Primary parent first. Empty for `seed` and for `unknown` attribution; a
+   * parent in another search appears only on a `derive` edge. */
+  parents: SearchNodeRef[];
+  operator: SearchEdgeOperator;
+  attribution: SearchEdgeAttribution;
+  /** Null only on a `seed` edge: the search's starting artifact was not proposed. */
+  proposer: SearchProposer | null;
+  /** Why the policy chose these parents. */
+  selection: {
+    rule: string;
+    evidence: Record<string, number>;
+  } | null;
+  /** The proposer's redacted rationale. */
+  rationale: SearchArtifactRef | SearchUnknown;
+  /** One diff per parent, parent to child. */
+  diffs: Array<SearchArtifactRef | SearchUnknown>;
+  /** At most 200 characters, redacted. */
+  label: string;
+}
+/** One node on one task in one split at one repeat is planned. `cellId` is
+ * `searchCellId(searchId, nodeId, taskId, split, rep)`. */
+interface SearchCellAllocatedEvent extends SearchLedgerEventBase {
+  kind: 'cell-allocated';
+  cellId: string;
+  nodeId: string;
+  taskId: string;
+  unitId: string;
+  split: SearchSplit;
+  rep: number;
+  stage: SearchCellStage;
+  lane: string | null;
+  /** Null when no reservation was made: an external optimizer dispatched the cell. */
+  reservation: SearchReservation | null;
+}
+/** One attempt at a cell finished. Its RunRecord, when the producer minted one,
+ * is an artifact with role `run-record`. */
+interface SearchCellSettledEvent extends SearchLedgerEventBase {
+  kind: 'cell-settled';
+  cellId: string;
+  /** Counted from 1 without gaps. */
+  attempt: number;
+  /** `searchCellRunId({ cellId, attempt })`. */
+  runId: string;
+  outcome: SearchTaskOutcome;
+  accounting: SearchAttemptAccounting;
+  boxMinutes: number | null;
+  wallMs: number | null;
+  queueMs: number | null;
+  placement: {
+    lane: string;
+    boxId: string | null;
+  } | null;
+  identity: SearchExecutionIdentity;
+  surfaceEvidence: SearchSurfaceEvidence[];
+  traceRef: SearchTraceRef;
+}
+interface SearchCellCancelledEvent extends SearchLedgerEventBase {
+  kind: 'cell-cancelled';
+  cellId: string;
+  reason: SearchCancelReason;
+}
+/** A policy, allocator or claim decision about a node. May repeat; the latest wins. */
+interface SearchNodeDecidedEvent extends SearchLedgerEventBase {
+  kind: 'node-decided';
+  nodeId: string;
+  decision: SearchNodeDecision;
+  basis: NodeEstimate | null;
+  rule: string;
+  reason: string;
+}
+/** Last event, once. More work on a closed search is a derived search. */
+interface SearchClosedEvent extends SearchLedgerEventBase {
+  kind: 'search-closed';
+  reason: SearchCloseReason;
+  claim: SearchClaim | null;
+}
+type SearchLedgerEvent = SearchOpenedEvent | SearchOperationStartedEvent | SearchOperationRecordedEvent | SearchNodeRegisteredEvent | SearchEdgeRecordedEvent | SearchCellAllocatedEvent | SearchCellSettledEvent | SearchCellCancelledEvent | SearchNodeDecidedEvent | SearchClosedEvent;
+interface SearchLedgerEntry {
+  schema: typeof SEARCH_LEDGER_SCHEMA;
+  searchId: string;
+  sequence: number;
+  previousHash: SearchLedgerHash | null;
+  event: SearchLedgerEvent;
+  entryHash: SearchLedgerHash;
+}
+/** Counts and sums over the whole search. Every field is a number or a short
+ * scalar, so reading the audit costs the same at any search size. */
+interface SearchAudit {
+  searchId: string;
+  eventCount: number;
+  headHash: SearchLedgerHash | null;
+  status: 'open' | 'closed';
+  closeReason: SearchCloseReason | null;
+  nodes: number;
+  /** Nodes with no edge yet: not placed in the tree. */
+  nodesWithoutEdge: number;
+  /** Nodes whose latest decision is missing or `advanced`. */
+  undecidedNodes: number;
+  selectedNodeId: string | null;
+  edges: {
+    explicit: number;
+    correlated: number;
+    unknown: number;
+    reproposals: number;
+  };
+  cells: {
+    allocated: number;
+    settled: number;
+    cancelled: number;
+    open: number;
+  };
+  attempts: number;
+  outcomes: {
+    passed: number;
+    failed: number;
+    errored: number;
+  };
+  operations: {
+    started: number;
+    recorded: number;
+    open: number;
+  };
+  spend: {
+    /** Sum of known cell and operation costs. */
+    knownUsd: number;
+    /** Sum of the proven lower bounds of unknown costs. */
+    floorUsd: number;
+    unknownCostCells: number;
+    unknownCostOperations: number;
+    /** knownUsd + floorUsd. */
+    committedUsd: number;
+    /** Reservations of unsettled cells and unrecorded operations, net of their spend so far. */
+    openReservationUsd: number;
+    /** Spend above reservations. */
+    overspendUsd: number;
+    /** Settled cells that ran without a reservation. */
+    unreservedCells: number;
+    boxMinutes: number;
+  };
+  tokens: {
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    unknownTokenAttempts: number;
+  };
+}
+//#endregion
+export { SearchNodeDecision as A, SearchReservation as B, SearchExecutionIdentity as C, SearchLedgerHash as D, SearchLedgerEvent as E, SearchOperationKind as F, SearchSurfaceEffect as G, SearchSplit as H, SearchOperationRecordedEvent as I, SearchTask as J, SearchSurfaceEvidence as K, SearchOperationStartedEvent as L, SearchNodeRegisteredEvent as M, SearchNodeStatus as N, SearchModelIdentity as O, SearchOpenedEvent as P, SearchUnknown as Q, SearchProposer as R, SearchEstimateMethod as S, SearchLedgerEntry as T, SearchSplitTasks as U, SearchSourceRef as V, SearchSplits as W, SearchTokenAccounting as X, SearchTaskOutcome as Y, SearchTraceRef as Z, SearchClosedEvent as _, SearchAttemptAccounting as a, SearchEdgeOperator as b, SearchCancelReason as c, SearchCellCancelledEvent as d, SearchCellSettledEvent as f, SearchCloseReason as g, SearchClaimPower as h, SearchArtifactRef as i, SearchNodeRef as j, SearchNodeDecidedEvent as k, SearchCandidateSurface as l, SearchClaim as m, SEARCH_LEDGER_SCHEMA as n, SearchAudit as o, SearchCellStage as p, SearchSurfaceKind as q, SearchArtifactKind as r, SearchBudget as s, NodeEstimate as t, SearchCellAllocatedEvent as u, SearchCostAccounting as v, SearchFailureReason as w, SearchEdgeRecordedEvent as x, SearchEdgeAttribution as y, SearchProposerKind as z };
+//# sourceMappingURL=search-ledger-types-C9anU2DX.d.ts.map

package/dist/search-ledger-types-C9anU2DX.d.ts.map

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

package/dist/{semantic-concept-judge-Cm2K2wAo.js → semantic-concept-judge-ClB73cei.js}

@@ -1,9 +1,9 @@
 import { i as CostLedger } from "./cost-ledger-_IbkejCF.js";
-import { u as Mutex } from "./journal-CDP0Vhx_.js";
-import { N as RawAnalystFindingSchema } from "./kind-factory-BGwN0nE6.js";
-import { c as extractJsonPayload } from "./llm-client-DF9bPNYA.js";
-import { n as paidJsonChat, t as paidChat } from "./chat-json-call-JVGbfx95.js";
-import { n as decodeRawFindingArray } from "./dspy-rlm-engine-DLYttKBm.js";
+import { f as Mutex } from "./journal-c3qY0SDP.js";
+import { N as RawAnalystFindingSchema } from "./kind-factory-ByZeXDqF.js";
+import { c as extractJsonPayload } from "./llm-client-KYQBh9C8.js";
+import { n as paidJsonChat, t as paidChat } from "./chat-json-call-CXHBvUz8.js";
+import { n as decodeRawFindingArray } from "./dspy-rlm-engine-Cs5LzJ-f.js";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { z } from "zod";
 import { dirname } from "node:path";
@@ -777,4 +777,4 @@ async function runSemanticConceptJudge(input, options) {
 //#endregion
 export { diffFindings as a, defaultIsMaterial as i, runSemanticConceptJudge as n, createChatTraceEngine as o, FindingsStore as r, SEMANTIC_CONCEPT_JUDGE_VERSION as t };
 
-//# sourceMappingURL=semantic-concept-judge-Cm2K2wAo.js.map
+//# sourceMappingURL=semantic-concept-judge-ClB73cei.js.map